水無瀬 優 postmaster@katsura-kotonoha.sakura.ne.jp
http://katsura-kotonoha.sakura.ne.jp/prog/code/tools/toolwind_cpp.shtml
| 水無瀬の部屋 > Programming > sample > tools > toolwind.cpp |
|---|
1: //*********************************************************
2: // プロジェクト: TOOLS
3: // ファイル名: toolwind.cpp
4: //*********************************************************
5: #include <header/toolwind.h>
6: #include <header/tooldbg.h> // ASSERT(), VERIFY(),
7: #include <header/toolbase.h> //
8: #include <header/toolsys.h> //
9: #include <header/toolptrc.h>
10: #include <limits.h> //
11:
12:
13: //---------------------------------------------------------
14: // マクロ の 定義
15: //---------------------------------------------------------
16: #define UINT_TO_HANDLE( u ) ((HANDLE)(UINT_PTR)( u )) // _W64
17:
18:
19: //------------------------------------------------------------------------------------------------------------------
20: // a
21: //------------------------------------------------------------------------------------------------------------------
22: //*********************************************************
23: // AllocDlgItemText
24: //*********************************************************
25: char *
26: AllocDlgItemText
27: (
28: HWND hWnd,
29: int nID
30: )
31: {
32: // パラメタの仮定
33: ASSERT( IsValidWindow( hWnd ) );
34: ASSERT( IsValidDlgItem( hWnd, nID ) );
35:
36: HWND hCtrl = GetDlgItem( hWnd, nID );
37: return AllocWindowText( hCtrl );
38: }//AllocDlgItemText
39:
40: //*********************************************************
41: // AllocWindowText
42: //*********************************************************
43: char *
44: AllocWindowText
45: (
46: HWND hWnd
47: )
48: {
49: // パラメタの仮定
50: ASSERT( IsValidWindow( hWnd ) );
51:
52: const int length = GetWindowTextLength( hWnd );
53: if ( length < 0 )
54: return null;
55:
56: char *buffer = (char *)malloc( (1 + length) * sizeof( *buffer ) );
57: if ( !buffer )
58: return null;
59:
60: if ( 0 <= GetWindowText( hWnd, buffer, 1 + length ) )
61: {
62: return buffer;
63: }
64:
65: free( buffer );
66: return null;
67: }//AllocWindowText
68:
69:
70: //------------------------------------------------------------------------------------------------------------------
71: // b
72: //------------------------------------------------------------------------------------------------------------------
73:
74: //------------------------------------------------------------------------------------------------------------------
75: // c
76: //------------------------------------------------------------------------------------------------------------------
77: //*********************************************************
78: // CenterWindow
79: //*********************************************************
80: bool
81: CenterWindow
82: (
83: HWND hChild,
84: HWND hParent
85: )
86: {
87: // パラメタの仮定
88: ASSERT( IsValidWindow( hChild ) );
89: ASSERT( IsValidWindow( hParent ) );
90: ASSERT( hParent == GetParent( hChild ) );
91:
92: POINT pt;
93: pt.x = ( GetWindowWidth(hParent) - GetWindowWidth(hChild) ) / 2;
94: pt.y = ( GetWindowHeight(hParent) - GetWindowHeight(hChild) ) / 2;
95: VERIFY( WindowToScreen( hParent, &pt ) );
96:
97: // デスクトップ作業領域に表示されるよう移動する
98: RECT rcWorkarea;
99: VERIFY( GetWorkareaRect( &rcWorkarea ) );
100: if ( pt.x > rcWorkarea.right - GetWindowWidth(hChild) )
101: pt.x = rcWorkarea.right - GetWindowWidth(hChild);
102: if ( pt.x < rcWorkarea.left )
103: pt.x = rcWorkarea.left;
104: if ( pt.y > rcWorkarea.bottom - GetWindowHeight(hChild) )
105: pt.y = rcWorkarea.bottom - GetWindowHeight(hChild);
106: if ( pt.y < rcWorkarea.top )
107: pt.y = rcWorkarea.top;
108:
109: return boolean_cast( WindowMove( hChild, pt.x, pt.y ) );
110: }//CenterWindow
111:
112: //*********************************************************
113: // ClientRectToScreenRect
114: // クライアント座標の矩形 rc をスクリーン座標に変換する
115: //*********************************************************
116: bool
117: ClientRectToScreenRect
118: (
119: HWND hWnd,
120: RECT *rc
121: )
122: {
123: // パラメタの仮定
124: ASSERT( IsValidWindow( hWnd ) );
125: ASSERT( IsValidPtr( rc, sizeof( *rc ) ) );
126: ASSERT( IsValidRect( rc ) );
127:
128: POINT pt = { 0, 0 };
129: if ( !ClientToScreen( hWnd, &pt ) )
130: return false;
131:
132: VERIFY( OffsetRect( rc, pt.x , pt.y ) );
133: ASSERT( IsValidRect( rc ) );
134: return true;
135: }//ClientRectToScreenRect
136:
137: //*********************************************************
138: // ClientToWindow
139: // スクリーン座標 pt をウィンドウ座標に変換する
140: //*********************************************************
141: bool
142: ClientToWindow
143: (
144: HWND hWnd,
145: POINT *pt
146: )
147: {
148: // パラメタの仮定
149: ASSERT( IsValidWindow( hWnd ) );
150: ASSERT( IsValidPtr( pt, sizeof( *pt ) ) );
151:
152: VERIFY( ClientToScreen( hWnd, pt ) );
153: return ScreenToWindow( hWnd, pt );
154: }//ClientToWindow
155:
156: //*********************************************************
157: // CreateChildWindow
158: // 子ウィンドウを生成します
159: // 生成した子ウィンドウへのハンドルを返します
160: //*********************************************************
161: HWND
162: CreateChildWindow
163: (
164: DWORD dwExStyle,
165: const char *ClassName,
166: const char *text,
167: DWORD dwStyle,
168: int x,
169: int y,
170: int width,
171: int height,
172: HWND hParent,
173: UINT uID,
174: HINSTANCE hInstance,
175: void *param
176: )
177: {
178: // パラメタの仮定
179: ASSERT( IsValidStringPtr( ClassName ) );
180: ASSERT( IsValidStringPtr( text ) );
181: ASSERT( WS_CHILD == (WS_CHILD & dwStyle) );
182: ASSERT( IsValidWindow( hParent ) );
183: ASSERT( (0 < uID) && (uID < USHRT_MAX) );
184: ASSERT( IsValidInstanceHandle( hInstance ) );
185:
186: HWND hWnd = CreateWindowEx
187: (
188: dwExStyle,
189: ClassName,
190: text,
191: dwStyle,
192: x,
193: y,
194: width,
195: height,
196: hParent,
197: (HMENU)UINT_TO_HANDLE( uID ),
198: hInstance,
199: param
200: );
201:
202: return hWnd;
203: }//CreateChildWindow
204:
205: //*********************************************************
206: // CreateWindowIndirect
207: // ウィンドウを生成します
208: // 生成したウィンドウへのハンドルを返します
209: //*********************************************************
210: HWND
211: CreateWindowIndirect
212: (
213: const CREATESTRUCT *cs
214: )
215: {
216: // パラメタの仮定
217: ASSERT( IsValidReadPtr( cs, sizeof( *cs ) ) );
218: ASSERT( IsValidStringPtr( cs->lpszName ) );
219: ASSERT( !cs->hwndParent
220: || IsValidWindow( cs->hwndParent ) );
221:
222: return CreateWindowEx
223: (
224: cs->dwExStyle, //
225: cs->lpszClass, //
226: cs->lpszName, // ウィンドウ・テキスト
227: cs->style, //
228: cs->x, // x 位置
229: cs->y, // y 位置
230: cs->cx, // 幅
231: cs->cy, // 高さ
232: cs->hwndParent, //
233: cs->hMenu, //
234: cs->hInstance, //
235: cs->lpCreateParams //
236: );
237: }//CreateWindowIndirect
238:
239: //*********************************************************
240: // CursorInClient
241: //*********************************************************
242: bool
243: CursorInClient
244: (
245: HWND hWnd
246: )
247: {
248: // パラメタの仮定
249: ASSERT( IsValidWindow( hWnd ) );
250:
251: RECT rcClient;
252: VERIFY( GetClientRect( hWnd, &rcClient ) );
253:
254: POINT ptClient;
255: VERIFY( GetClientCursorPos( hWnd, &ptClient ) );
256:
257: return !! PtInRect( &rcClient, ptClient );
258: }//CursorInClient
259:
260:
261: //------------------------------------------------------------------------------------------------------------------
262: // d
263: //------------------------------------------------------------------------------------------------------------------
264: //*********************************************************
265: // DeferWindowMove
266: //*********************************************************
267: HDWP
268: DeferWindowMove
269: (
270: HDWP *phWinPosInfo,
271: HWND hWnd,
272: int nPosX,
273: int nPosY
274: )
275: {
276: // パラメタの仮定
277: ASSERT( IsValidWindow( hWnd ) );
278: ASSERT( IsValidPtr( phWinPosInfo, sizeof( *phWinPosInfo ) ) );
279: ASSERT( *phWinPosInfo );
280:
281: *phWinPosInfo = DeferWindowPos( *phWinPosInfo, hWnd, null, nPosX, nPosY, 0, 0, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER );
282: return *phWinPosInfo;
283: }//DeferWindowMove
284:
285: //*********************************************************
286: // DialogBoxPtrParam
287: //*********************************************************
288: INT_PTR
289: DialogBoxPtrParam
290: (
291: HINSTANCE hInstance,
292: const char *name,
293: HWND hwndParent,
294: DLGPROC proc,
295: const void *param
296: )
297: {
298: // パラメタの仮定
299: ASSERT( IsValidInstanceHandle( hInstance ) );
300: ASSERT( IsValidResourceName( name ) );
301: ASSERT( !hwndParent || IsValidWindow( hwndParent ) );
302: ASSERT( IsValidCodePtr( proc ) );
303:
304: return DialogBoxParam
305: (
306: hInstance,
307: name,
308: hwndParent,
309: proc,
310: reinterpret_cast<LPARAM>( param )
311: );
312: }//DialogBoxPtrParam
313:
314:
315: //------------------------------------------------------------------------------------------------------------------
316: // e
317: //------------------------------------------------------------------------------------------------------------------
318: //*********************************************************
319: // EnableDlgItem
320: // ウィンドウ hWnd の識別子 nID を持つ子ウィンドウを有効化または無効化する
321: // bErase …… 真を指定するとウィンドウを有効化する
322: //*********************************************************
323: bool
324: EnableDlgItem
325: (
326: HWND hWnd,
327: int nID,
328: bool bEnable
329: )
330: {
331: // パラメタの仮定
332: ASSERT( IsValidWindow( hWnd ) );
333: ASSERT( IsValidDlgItem( hWnd, nID ) );
334:
335: HWND hCtrl = GetDlgItem( hWnd, nID );
336: return !! EnableWindow( hCtrl, bEnable );
337: }//EnableDlgItem
338:
339:
340: //------------------------------------------------------------------------------------------------------------------
341: // f
342: //------------------------------------------------------------------------------------------------------------------
343:
344: //------------------------------------------------------------------------------------------------------------------
345: // g
346: //------------------------------------------------------------------------------------------------------------------
347: //*********************************************************
348: // GetClientHeight
349: // クライアント領域の高さを返す
350: //*********************************************************
351: int
352: GetClientHeight
353: (
354: HWND hWnd
355: )
356: {
357: // パラメタの仮定
358: ASSERT( IsValidWindow( hWnd ) );
359:
360: SIZE szClient;
361: VERIFY( GetClientSize( hWnd, &szClient ) );
362: return szClient.cy;
363: }//GetClientHeight
364:
365: //*********************************************************
366: // GetClientSize
367: // クライアント領域の大きさを得る
368: //*********************************************************
369: bool
370: GetClientSize
371: (
372: HWND hWnd,
373: SIZE *size
374: )
375: {
376: // パラメタの仮定
377: ASSERT( IsValidWindow( hWnd ) );
378: ASSERT( IsValidPtr( size, sizeof( *size ) ) );
379:
380: RECT rcClient;
381: VERIFY( GetClientRect( hWnd, &rcClient ) );
382: VERIFY( GetRectSize( &rcClient, size ) );
383: return true;
384: }//GetClientSize
385:
386: //*********************************************************
387: // GetClientWidth
388: // クライアント領域の幅を返す
389: //*********************************************************
390: int
391: GetClientWidth
392: (
393: HWND hWnd
394: )
395: {
396: // パラメタの仮定
397: ASSERT( IsValidWindow( hWnd ) );
398:
399: SIZE szClient;
400: VERIFY( GetClientSize( hWnd, &szClient ) );
401: return szClient.cx;
402: }//GetClientWidth
403:
404: //*********************************************************
405: // GetClassBrush
406: //*********************************************************
407: HBRUSH
408: GetClassBrush
409: (
410: HWND hWnd
411: )
412: {
413: // パラメタの仮定
414: ASSERT( IsValidWindow( hWnd ) );
415:
416: return (HBRUSH)GetClassLongPtr64( hWnd, GCL_HBRBACKGROUND );
417: }//GetClassBrush
418:
419: //*********************************************************
420: // GetClassCursor
421: //*********************************************************
422: HCURSOR
423: GetClassCursor
424: (
425: HWND hWnd
426: )
427: {
428: // パラメタの仮定
429: ASSERT( IsValidWindow( hWnd ) );
430:
431: return (HCURSOR)GetClassLongPtr64( hWnd, GCL_HCURSOR );
432: }//GetClassCursor
433:
434: //*********************************************************
435: // GetClassIcon
436: // fType --- ICON_BIG, ICON_SMALL
437: //*********************************************************
438: HICON
439: GetClassIcon
440: (
441: HWND hWnd,
442: WPARAM fType
443: )
444: {
445: // パラメタの仮定
446: ASSERT( IsValidWindow( hWnd ) );
447: ASSERT( ( ICON_BIG == fType )
448: || ( ICON_SMALL == fType ) );
449:
450: return (HICON)GetClassLongPtr64( hWnd, (ICON_BIG == fType) ? GCL_HICON : GCL_HICONSM );
451: }//GetClassIcon
452:
453: //*********************************************************
454: // GetClassModule
455: //*********************************************************
456: HMODULE
457: GetClassModule
458: (
459: HWND hWnd
460: )
461: {
462: // パラメタの仮定
463: ASSERT( IsValidWindow( hWnd ) );
464:
465: return (HMODULE)GetClassLongPtr64( hWnd, GCL_HMODULE );
466: }//GetClassModule
467:
468: //*********************************************************
469: // GetClassStyle
470: //*********************************************************
471: DWORD
472: GetClassStyle
473: (
474: HWND hWnd
475: )
476: {
477: // パラメタの仮定
478: ASSERT( IsValidWindow( hWnd ) );
479:
480: return (DWORD)GetClassLongPtr64( hWnd, GCL_STYLE );
481: }//GetClassStyle
482:
483: //*********************************************************
484: // GetCurrentDisplaySetting
485: //*********************************************************
486: bool
487: GetCurrentDisplaySetting
488: (
489: DEVMODE *dev
490: )
491: {
492: // パラメタの仮定
493: ASSERT( IsValidPtr( dev, sizeof( *dev ) ) );
494:
495: return !! EnumDisplaySettings( null, ENUM_CURRENT_SETTINGS, dev );
496: }//GetCurrentDisplaySetting
497:
498: //*********************************************************
499: // GetDragFileCount
500: //*********************************************************
501: UINT
502: GetDragFileCount
503: (
504: HDROP hDrop
505: )
506: {
507: // パラメタの仮定
508: // ASSERT( hDrop );
509:
510: return DragQueryFile( hDrop, 0xFFFFFFFF, null, 0 );
511: }//GetDragFileCount
512:
513: //*********************************************************
514: // GetDlgItemTop
515: //*********************************************************
516: int
517: GetDlgItemTop
518: (
519: HWND hWnd,
520: int nID
521: )
522: {
523: // パラメタの仮定
524: ASSERT( IsValidWindow( hWnd ) );
525: ASSERT( IsValidDlgItem( hWnd, nID ) );
526:
527: HWND hCtrl = GetDlgItem( hWnd, nID );
528: return GetWindowTop( hCtrl );
529: }//GetDlgItemTop
530:
531: //*********************************************************
532: // GetDlgItemBottom
533: //*********************************************************
534: int
535: GetDlgItemBottom
536: (
537: HWND hWnd,
538: int nID
539: )
540: {
541: // パラメタの仮定
542: ASSERT( IsValidWindow( hWnd ) );
543: ASSERT( IsValidDlgItem( hWnd, nID ) );
544:
545: HWND hCtrl = GetDlgItem( hWnd, nID );
546: return GetWindowBottom( hCtrl );
547: }//GetDlgItemBottom
548:
549: //*********************************************************
550: // GetDlgItemTextLength
551: //*********************************************************
552: int
553: GetDlgItemTextLength
554: (
555: HWND hWnd,
556: int nID
557: )
558: {
559: // パラメタの仮定
560: ASSERT( IsValidWindow( hWnd ) );
561: ASSERT( IsValidDlgItem( hWnd, nID ) );
562:
563: HWND hCtrl = GetDlgItem( hWnd, nID );
564: return GetWindowTextLength( hCtrl );
565: }//GetDlgItemTextLength
566:
567: //*********************************************************
568: // GetMenuItemPos()
569: // メニュー項目 の 0 開始位置 を得る。
570: // 項目が見つからない場合は -1 を返す。
571: //
572: // HMENU hMenu
573: // 項目を含む 親メニュー のハンドル
574: //
575: // UINT uID
576: // 位置を求めるメニュー項目の 項目識別子
577: //
578: //*********************************************************
579: int // 0 開始位置
580: GetMenuItemPos
581: (
582: HMENU hMenu, // 親メニューのハンドル
583: UINT uID // メニュー項目の項目識別子
584: )
585: {
586: // パラメタの仮定
587: ASSERT( IsValidMenu( hMenu ) );
588: ASSERT( INVALID_MENUITEMID != uID );
589:
590: const int count = GetMenuItemCount( hMenu );
591: {for( int pos = 0; pos < count; ++pos )
592: {
593: if ( uID == GetMenuItemID( hMenu, pos ) )
594: return pos;
595: }}
596:
597: return -1;
598: }//GetMenuItemPos
599:
600: //*********************************************************
601: // GetMenuStringLength()
602: // メニュー項目 の 文字列長 を得る。
603: // 関数が失敗すると 0 を返す。
604: //
605: // HMENU hMenu
606: // 項目を含む 親メニュー のハンドル
607: //
608: // UINT uID
609: // flags が MF_BYCOMMAND の場合
610: // メニュー項目の 項目識別子
611: // flags が MF_BYPOSITION の場合
612: // メニュー項目の 0 開始位置
613: //
614: // UINT flags
615: // uID の意味を指定する。
616: // MF_BYCOMMAND or MF_BYPOSITION
617: //
618: //*********************************************************
619: int // 文字列長
620: GetMenuStringLength
621: (
622: HMENU hMenu, // 親メニューのハンドル
623: UINT uID, // メニュー項目の 識別子 or 位置
624: UINT flags // MF_BYCOMMAND or MF_BYPOSITION
625: )
626: {
627: // パラメタの仮定
628: ASSERT( IsValidMenu( hMenu ) );
629: ASSERT( INVALID_MENUITEMID != uID );
630: ASSERT( (MF_BYCOMMAND == flags)
631: || (MF_BYPOSITION == flags) );
632:
633: return GetMenuString( hMenu, uID, null, 0, flags );
634: }//GetMenuStringLength
635:
636: //*********************************************************
637: // GetNextDlgItem
638: // ウィンドウ hDlg の識別子 nID を持つ子ウィンドウの次のウィンドウを得る
639: //*********************************************************
640: HWND // 次のウィンドウ
641: GetNextDlgItem
642: (
643: HWND hDlg, //
644: int nID //
645: )
646: {
647: // パラメタの仮定
648: ASSERT( IsValidWindow( hDlg ) );
649: ASSERT( IsValidDlgItem( hDlg, nID ) );
650:
651: HWND hwndDlgItem = GetDlgItem( hDlg, nID );
652: return GetNextWindow( hwndDlgItem, GW_HWNDNEXT );
653: }//GetNextDlgItem
654:
655: //*********************************************************
656: // GetNotifyMessageControlID
657: //*********************************************************
658: UINT_PTR
659: GetNotifyMessageControlID
660: (
661: LPARAM lParam
662: )
663: {
664: // パラメタの仮定
665: ASSERT( IsValidPtr( (NMHDR *)lParam, sizeof( NMHDR ) ) );
666:
667: const NMHDR *nmhdr = GetNotifyMessageParam( lParam );
668: return nmhdr->idFrom;
669: }//GetNotifyMessageControlID
670:
671: //*********************************************************
672: // GetNotifyMessageNotifyCode
673: //*********************************************************
674: UINT
675: GetNotifyMessageNotifyCode
676: (
677: LPARAM lParam
678: )
679: {
680: // パラメタの仮定
681: ASSERT( IsValidPtr( (NMHDR *)lParam, sizeof( NMHDR ) ) );
682:
683: const NMHDR *nmhdr = GetNotifyMessageParam( lParam );
684: return nmhdr->code;
685: }//GetNotifyMessageNotifyCode
686:
687: //*********************************************************
688: // GetNotifyMessageParam
689: //*********************************************************
690: NMHDR *
691: GetNotifyMessageParam
692: (
693: LPARAM lParam
694: )
695: {
696: // パラメタの仮定
697: ASSERT( IsValidPtr( (NMHDR *)lParam, sizeof( NMHDR ) ) );
698:
699: return reinterpret_cast<NMHDR *>( lParam );
700: }//GetNotifyMessageParam
701:
702: //*********************************************************
703: // GetNotifyMessageWindow
704: //*********************************************************
705: HWND
706: GetNotifyMessageWindow
707: (
708: LPARAM lParam
709: )
710: {
711: // パラメタの仮定
712: ASSERT( IsValidPtr( (NMHDR *)lParam, sizeof( NMHDR ) ) );
713:
714: const NMHDR *nmhdr = GetNotifyMessageParam( lParam );
715: return nmhdr->hwndFrom;
716: }//GetNotifyMessageWindow
717:
718: //*********************************************************
719: // GetScreenRect
720: // デスクトップ領域の矩形 rcScreen を得る
721: //*********************************************************
722: bool
723: GetScreenRect
724: (
725: RECT *rcScreen
726: )
727: {
728: // パラメタの仮定
729: ASSERT( IsValidPtr( rcScreen, sizeof( *rcScreen ) ) );
730:
731: rcScreen->left = 0;
732: rcScreen->top = 0;
733: rcScreen->right = GetSystemMetrics(SM_CXSCREEN);
734: rcScreen->bottom = GetSystemMetrics(SM_CYSCREEN);
735: ASSERT( IsValidRect( rcScreen ) );
736: return true;
737: }//GetScreenRect
738:
739: //*********************************************************
740: // GetWindowTop
741: //*********************************************************
742: int
743: GetWindowTop
744: (
745: HWND hWnd
746: )
747: {
748: // パラメタの仮定
749: ASSERT( IsValidWindow( hWnd ) );
750:
751: POINT pt;
752: GetWindowPoint(hWnd, &pt);
753: return pt.y;
754: }//GetWindowTop
755:
756: //*********************************************************
757: // GetWindowBottom
758: //*********************************************************
759: int
760: GetWindowBottom
761: (
762: HWND hWnd
763: )
764: {
765: // パラメタの仮定
766: ASSERT( IsValidWindow( hWnd ) );
767:
768: return GetWindowTop( hWnd ) + GetWindowHeight( hWnd );
769: }//GetWindowBottom
770:
771: //*********************************************************
772: // GetWindowHeight
773: // ウィンドウ hWnd の高さを返す
774: //*********************************************************
775: int
776: GetWindowHeight
777: (
778: HWND hWnd
779: )
780: {
781: // パラメタの仮定
782: ASSERT( IsValidWindow( hWnd ) );
783:
784: SIZE szWindow;
785: VERIFY( GetWindowSize( hWnd, &szWindow ) );
786: return szWindow.cy;
787: }//GetWindowHeight
788:
789: //*********************************************************
790: // GetWindowIcon
791: // fType …… ICON_BIG, ICON_SMALL
792: //*********************************************************
793: HICON
794: GetWindowIcon
795: (
796: HWND hWnd,
797: WPARAM fType
798: )
799: {
800: // パラメタの仮定
801: ASSERT( IsValidWindow( hWnd ) );
802: ASSERT( (ICON_BIG == fType)
803: || (ICON_SMALL == fType) );
804:
805: return (HICON)SendMessage( hWnd, WM_GETICON, fType, 0 );
806: }//GetWindowIcon
807:
808: //*********************************************************
809: // GetWindowLogFont
810: //*********************************************************
811: bool
812: GetWindowLogFont
813: (
814: HWND hWnd,
815: LOGFONT *lf
816: )
817: {
818: // パラメタの仮定
819: ASSERT( IsValidWindow( hWnd ) );
820: ASSERT( IsValidPtr( lf, sizeof( *lf ) ) );
821:
822: HFONT hFont = GetWindowFont( hWnd );
823: if ( !hFont )
824: return false;
825:
826: //
827: if ( sizeof( *lf ) != GetObject( hFont, sizeof( *lf ), lf ) )
828: return false;
829:
830: return true;
831: }//GetWindowLogFont
832:
833: //*********************************************************
834: // GetWindowNormalHeight
835: // ウィンドウ hWnd の復元時の高さを返す
836: //*********************************************************
837: int
838: GetWindowNormalHeight
839: (
840: HWND hWnd
841: )
842: {
843: // パラメタの仮定
844: ASSERT( IsValidWindow( hWnd ) );
845:
846: RECT rcWindow;
847: VERIFY( GetWindowNormalRect( hWnd, &rcWindow ) );
848: return GetRectHeight( &rcWindow );
849: }//GetWindowNormalHeight
850:
851: //*********************************************************
852: // GetWindowNormalRect
853: //*********************************************************
854: bool
855: GetWindowNormalRect
856: (
857: HWND hWnd,
858: RECT *rcWindow
859: )
860: {
861: // パラメタの仮定
862: ASSERT( IsValidWindow( hWnd ) );
863: ASSERT( IsValidPtr( rcWindow, sizeof( *rcWindow ) ) );
864:
865: //
866: WINDOWPLACEMENT wndpl;
867: memzero( &wndpl, sizeof( wndpl ) );
868: wndpl.length = sizeof( wndpl );
869: const bool bSuccess = !! GetWindowPlacement( hWnd, &wndpl );
870: ASSERT( IsValidRect( &wndpl.rcNormalPosition ) );
871:
872: //
873: VERIFY( CopyRect( rcWindow, &wndpl.rcNormalPosition ) );
874: ASSERT( IsValidRect( rcWindow ) );
875: return bSuccess;
876: }//GetWindowNormalRect
877:
878: //*********************************************************
879: // GetWindowNormalWidth
880: // ウィンドウ hWnd の復元時の幅を返す
881: //*********************************************************
882: int
883: GetWindowNormalWidth
884: (
885: HWND hWnd
886: )
887: {
888: // パラメタの仮定
889: ASSERT( IsValidWindow( hWnd ) );
890:
891: RECT rcWindow;
892: VERIFY( GetWindowNormalRect( hWnd, &rcWindow ) );
893: return GetRectWidth( &rcWindow );
894: }//GetWindowNormalWidth
895:
896: //*********************************************************
897: // GetWindowPoint
898: // ウィンドウ hWnd の左上隅のスクリーン座標を得る
899: //*********************************************************
900: bool
901: GetWindowPoint
902: (
903: HWND hWnd,
904: POINT *pt
905: )
906: {
907: // パラメタの仮定
908: ASSERT( IsValidWindow( hWnd ) );
909: ASSERT( IsValidPtr( pt, sizeof( *pt ) ) );
910:
911: RECT rcWindow;
912: VERIFY( GetWindowRect( hWnd, &rcWindow ) );
913: VERIFY( MakePoint( pt, rcWindow.left, rcWindow.top ) );
914: return true;
915: }//GetWindowPoint
916:
917: //*********************************************************
918: // GetWindowPriority
919: //*********************************************************
920: bool
921: GetWindowPriority
922: (
923: HWND hWnd,
924: DWORD *pdwPriorityClass
925: )
926: {
927: // パラメタの仮定
928: ASSERT( IsValidWindow( hWnd ) );
929: ASSERT( IsValidPtr( pdwPriorityClass, sizeof( *pdwPriorityClass ) ) );
930:
931: HANDLE hProcess = OpenWindowProcess( hWnd, PROCESS_ALL_ACCESS, false );
932: if ( !hProcess )
933: return false;
934:
935: *pdwPriorityClass = GetPriorityClass( hProcess );
936: VERIFY( CloseHandle( hProcess ) );
937: return true;
938: }//GetWindowPriority
939:
940: //*********************************************************
941: // GetWindowSize
942: // ウィンドウ hWnd の大きさを得る
943: //*********************************************************
944: bool
945: GetWindowSize
946: (
947: HWND hWnd,
948: SIZE *size
949: )
950: {
951: // パラメタの仮定
952: ASSERT( IsValidWindow( hWnd ) );
953: ASSERT( IsValidPtr( size, sizeof( *size ) ) );
954:
955: RECT rcWindow;
956: VERIFY( GetWindowRect( hWnd, &rcWindow ) );
957: VERIFY( GetRectSize( &rcWindow, size ) );
958: return true;
959: }//GetWindowSize
960:
961: //*********************************************************
962: // GetWindowWidth
963: // ウィンドウ hWnd の幅を返す
964: //*********************************************************
965: int
966: GetWindowWidth
967: (
968: HWND hWnd
969: )
970: {
971: // パラメタの仮定
972: ASSERT( IsValidWindow( hWnd ) );
973:
974: SIZE szWindow;
975: VERIFY( GetWindowSize( hWnd, &szWindow ) );
976: return szWindow.cx;
977: }//GetWindowWidth
978:
979: //*********************************************************
980: // GetWorkareaRect
981: // デスクトップ作業領域の矩形 rcWorkarea を得る
982: //*********************************************************
983: bool
984: GetWorkareaRect
985: (
986: RECT *rcWorkarea
987: )
988: {
989: // パラメタの仮定
990: ASSERT( IsValidPtr( rcWorkarea, sizeof( *rcWorkarea ) ) );
991:
992: return !! SystemParametersInfo( SPI_GETWORKAREA, 0, rcWorkarea, 0 );
993: }//GetWorkareaRect
994:
995:
996: //------------------------------------------------------------------------------------------------------------------
997: // h
998: //------------------------------------------------------------------------------------------------------------------
999:
1000: //------------------------------------------------------------------------------------------------------------------
1001: // i
1002: //------------------------------------------------------------------------------------------------------------------
1003: //*********************************************************
1004: // InvalidateDlgItem
1005: // ウィンドウ hWnd の識別子 nID を持つ子ウィンドウのクライアント領域全体を更新領域に追加する
1006: // bErase …… 真を指定すると更新領域が処理される時に更新領域内の背景が消去される
1007: //*********************************************************
1008: bool
1009: InvalidateDlgItem
1010: (
1011: HWND hWnd,
1012: int nID,
1013: bool bErase
1014: )
1015: {
1016: // パラメタの仮定
1017: ASSERT( IsValidWindow( hWnd ) );
1018: ASSERT( IsValidDlgItem( hWnd, nID ) );
1019:
1020: HWND hCtrl = GetDlgItem( hWnd, nID );
1021: return InvalidateWindow( hCtrl, bErase );
1022: }//InvalidateDlgItem
1023:
1024: //*********************************************************
1025: // InvalidateWindow
1026: // ウィンドウのクライアント領域全体を更新領域に追加する
1027: // bErase …… 真を指定すると更新領域が処理される時に更新領域内の背景が消去される
1028: //*********************************************************
1029: bool
1030: InvalidateWindow
1031: (
1032: HWND hWnd,
1033: bool bErase
1034: )
1035: {
1036: // パラメタの仮定
1037: ASSERT( IsValidWindow( hWnd ) );
1038:
1039: return boolean_cast( InvalidateRect( hWnd, null, bErase ) );
1040: }//InvalidateWindow
1041:
1042: //*********************************************************
1043: // IsClassNameWindow
1044: // ウィンドウ hWnd のクラス名が ClassName であれば真を返す
1045: //*********************************************************
1046: bool
1047: IsClassNameWindow
1048: (
1049: HWND hWnd,
1050: const char *ClassName
1051: )
1052: {
1053: // パラメタの仮定
1054: ASSERT( IsValidWindow( hWnd ) );
1055: ASSERT( IsValidStringPtr( ClassName ) );
1056:
1057: // クラス名を得る
1058: char buffer[ MAX_CLASSNAME+1 ];
1059: if ( 0 >= GetClassName( hWnd, buffer, numof(buffer)-1 ) )
1060: return false;
1061:
1062: // クラス名を比較する
1063: ASSERT( IsValidStringPtr( buffer ) );
1064: return streql( buffer, ClassName );
1065: }//IsClassNameWindow
1066:
1067: //*********************************************************
1068: // IsDlgItemEnabled
1069: // ウィンドウ hWnd の識別子 nID を持つ子ウィンドウが使用可能状態であれば真を返す
1070: //*********************************************************
1071: bool
1072: IsDlgItemEnabled
1073: (
1074: HWND hWnd,
1075: int nID
1076: )
1077: {
1078: // パラメタの仮定
1079: ASSERT( IsValidWindow( hWnd ) );
1080: ASSERT( IsValidDlgItem( hWnd, nID ) );
1081:
1082: HWND hCtrl = GetDlgItem( hWnd, nID );
1083: return !! IsWindowEnabled( hCtrl );
1084: }//IsDlgItemEnabled
1085:
1086: //*********************************************************
1087: // IsDlgItemVisible
1088: // ウィンドウ hWnd の識別子 nID を持つ子ウィンドウが表示状態であれば真を返す
1089: //*********************************************************
1090: bool
1091: IsDlgItemVisible
1092: (
1093: HWND hWnd,
1094: int nID
1095: )
1096: {
1097: // パラメタの仮定
1098: ASSERT( IsValidWindow( hWnd ) );
1099: ASSERT( IsValidDlgItem( hWnd, nID ) );
1100:
1101: HWND hCtrl = GetDlgItem( hWnd, nID );
1102: return !! IsWindowVisible( hCtrl );
1103: }//IsDlgItemVisible
1104:
1105: //*********************************************************
1106: // IsMenuItemChecked()
1107: // メニュー項目 の チェック状態 を取得する。
1108: // メニュー項目にチェックがされていれば 真 を返す。
1109: // 指定された メニュー項目 が無い場合は 偽 を返す。
1110: //
1111: // HMENU hMenu
1112: // 変更対象のメニュー項目を持つ 親メニュー のハンドル
1113: //
1114: // UINT uID
1115: // flags が MF_BYCOMMAND の場合
1116: // メニュー項目の 項目識別子
1117: // flags が MF_BYPOSITION の場合
1118: // メニュー項目の 0 開始位置
1119: //
1120: // UINT flags
1121: // uID の意味を指定する。
1122: // MF_BYCOMMAND or MF_BYPOSITION
1123: //
1124: //*********************************************************
1125: bool // チェックがされていれば 真
1126: IsMenuItemChecked
1127: (
1128: HMENU hMenu, // 親メニューのハンドル
1129: UINT uID, // メニュー項目の 識別子 or 位置
1130: UINT flags // MF_BYCOMMAND or MF_BYPOSITION
1131: )
1132: {
1133: // パラメタの仮定
1134: ASSERT( IsValidMenu( hMenu ) );
1135: ASSERT( INVALID_MENUITEMID != uID );
1136: ASSERT( (MF_BYCOMMAND == flags)
1137: || (MF_BYPOSITION == flags) );
1138:
1139: // 関数が失敗した場合は 偽 を返す。
1140: const UINT state = GetMenuState( hMenu, uID, flags );
1141: if ( INVALID_MENUITEMSTATE == state )
1142: {
1143: return false;
1144: }
1145:
1146: return MF_CHECKED == (MF_CHECKED & state);
1147: }//IsMenuItemChecked
1148:
1149: //*********************************************************
1150: // IsValidCharMessageParam - WM_CHAR
1151: // 文字キーが押下された
1152: // 常に 0L を返す
1153: // wParam …… 押下された文字の文字コード
1154: // lParam …… キーの押下に関する詳細
1155: // 0-15 …… 繰り返し数
1156: // 16-23 …… スキャンコード
1157: // 24 …… 拡張キーであれば 1 が設定される
1158: // 30 …… 自動反復中であれば 1 が設定される
1159: //
1160: // 使用例：
1161: // ASSERT( IsValidCharMessageParam( wParam, lParam ) );
1162: //
1163: //*********************************************************
1164: bool
1165: IsValidCharMessageParam
1166: (
1167: WPARAM wParam,
1168: LPARAM lParam
1169: )
1170: {
1171: VALID_TEST( 0 == (BIT( 29 ) & lParam) );
1172: VALID_TEST( 0 == (BIT( 31 ) & lParam) );
1173: VALID_TEST( wParam == ( 0xFF & wParam) );
1174: VALID_TEST( !jms1( wParam ) ); // ２バイト文字は独自に処理されているはず。
1175:
1176: return true;
1177: }//IsValidCharMessageParam
1178:
1179: //*********************************************************
1180: // IsValidCommandMessageParam() - WM_COMMAND
1181: // コマンド項目が選択された。
1182: // 返値の意味は要求されたコマンド項目による。
1183: // LOWORD(wParam) …… 選択されたコマンド項目の識別子。
1184: // メニューの区切り線が選択された場合は 0 が設定される。
1185: // HIWORD(wParam) …… 通知コード。
1186: // メッセージが メニュー から送信された場合は 0 が設定される。
1187: // メッセージがアクセラレータから送信された場合は 1 が設定される。
1188: // HWND lParam …… メッセージがコントロールから送信された場合はメッセージを送信したコントロールのハンドル。
1189: //
1190: // 使用例：
1191: // ASSERT( IsValidCommandMessageParam( wParam, lParam ) );
1192: //
1193: //*********************************************************
1194: bool
1195: IsValidCommandMessageParam
1196: (
1197: WPARAM wParam,
1198: LPARAM lParam
1199: )
1200: {
1201: const WORD wID = LOWORD( wParam );
1202: const WORD wNotifyCode = HIWORD( wParam );
1203: HWND hwndCtl = reinterpret_cast<HWND>( lParam );
1204:
1205: VALID_TEST( ( 0 != wID )
1206: || (( 0 == wID ) && ( 0 == wNotifyCode )) );
1207: VALID_TEST( ( 0 == wNotifyCode )
1208: || ( 1 == wNotifyCode )
1209: || IsValidWindow( hwndCtl ) );
1210:
1211: return true;
1212: }//IsValidCommandMessageParam
1213:
1214: //*********************************************************
1215: // IsValidControlColorDialogMessageParam - WM_CTLCOLORDLG
1216: // ダイアログが描画される。
1217: // ダイアログ背景を描画するための ブラシ を返す。
1218: // HDC wParam …… ダイアログのデバイスコンテキスト
1219: // HWND lParam …… ダイアログのハンドル
1220: //
1221: // 使用例：
1222: // ASSERT( IsValidControlColorDialogMessageParam( wParam, lParam ) );
1223: //
1224: //*********************************************************
1225: bool
1226: IsValidControlColorDialogMessageParam
1227: (
1228: WPARAM wParam,
1229: LPARAM lParam
1230: )
1231: {
1232: VALID_TEST( IsValidDeviceContextHandle( reinterpret_cast<HDC>( wParam ) ) );
1233: VALID_TEST( IsValidWindow( reinterpret_cast<HWND>( lParam ) ) );
1234:
1235: return true;
1236: }//IsValidControlColorDialogMessageParam
1237:
1238: //*********************************************************
1239: // IsValidControlColorStaticMessageParam - WM_CTLCOLORSTATIC
1240: // スタティック・コントロールが描画される。
1241: // コントロールの背景を描画するための ブラシ を返す。
1242: // HDC wParam …… コントロール の デバイスコンテキスト
1243: // HWND lParam …… コントロール の ウィンドウハンドル
1244: //
1245: // 使用例：
1246: // ASSERT( IsValidControlColorStaticMessageParam( wParam, lParam ) );
1247: //
1248: //*********************************************************
1249: bool
1250: IsValidControlColorStaticMessageParam
1251: (
1252: WPARAM wParam,
1253: LPARAM lParam
1254: )
1255: {
1256: VALID_TEST( IsValidDeviceContextHandle( reinterpret_cast<HDC>( wParam ) ) );
1257: VALID_TEST( IsValidWindow( reinterpret_cast<HWND>( lParam ) ) );
1258:
1259: return true;
1260: }//IsValidControlColorStaticMessageParam
1261:
1262: //*********************************************************
1263: // IsValidDlgItem
1264: // ウィンドウ hWnd に識別子 nID を持つ子ウィンドウが存在するならば真を返す
1265: //*********************************************************
1266: bool
1267: IsValidDlgItem
1268: (
1269: HWND hwndDlg,
1270: int nID
1271: )
1272: {
1273: VALID_TEST( IsValidWindow( hwndDlg ) );
1274:
1275: HWND hwndCtrl = GetDlgItem( hwndDlg, nID );
1276: VALID_TEST( IsValidWindow( hwndCtrl ) );
1277:
1278: return true;
1279: }//IsValidDlgItem
1280:
1281: //*********************************************************
1282: // IsValidInitDialogMessageParam - WM_INITDIALOG
1283: // ダイアログが作成された。
1284: // この関数が抜けるまでダイアログは表示されない。
1285: // 明示的にフォーカスを移動した場合は 真 を返せ。
1286: // さもなくば 偽 を返せ。
1287: // HWND wParam …… フォーカスを受け取る予定のコントロール
1288: // LPARAM lParam …… ダイアログの初期化パラメタ
1289: //
1290: // 使用例：
1291: // ASSERT( !IsWindowVisible( hWnd ) );
1292: // ASSERT( IsValidInitDialogMessageParam( wParam, lParam ) );
1293: //
1294: //*********************************************************
1295: bool
1296: IsValidInitDialogMessageParam
1297: (
1298: WPARAM wParam,
1299: LPARAM
1300: )
1301: {
1302: VALID_TEST( IsValidWindow( reinterpret_cast<HWND>( wParam ) ) );
1303:
1304: return true;
1305: }//IsValidInitDialogMessageParam
1306:
1307: //*********************************************************
1308: // IsValidKeyDownMessageParam - WM_KEYDOWN
1309: // キーが押下された
1310: // 返値の意味は押下されたキーの種類による
1311: // wParam …… 押下されたキーの仮想キーコード
1312: // lParam …… キーの押下に関する詳細
1313: // 0-15 …… 繰り返し数
1314: // 16-23 …… スキャンコード
1315: // 24 …… 拡張キーであれば 1 が設定される
1316: // 25-28 …… 使用せず
1317: // 29 …… コンテキストキー <詳細不明>
1318: // 30 …… 自動反復中であれば 1 が設定される
1319: // 31 …… WM_KEYDOWN では常に 0 が設定される
1320: //
1321: // 使用例：
1322: // ASSERT( IsValidKeyDownMessageParam( wParam, lParam ) );
1323: //
1324: //*********************************************************
1325: bool
1326: IsValidKeyDownMessageParam
1327: (
1328: WPARAM wParam,
1329: LPARAM lParam
1330: )
1331: {
1332: VALID_TEST( wParam == ( 0xFF & wParam) );
1333: VALID_TEST( 0 == (BIT( 31 ) & lParam) );
1334:
1335: return true;
1336: }//IsValidKeyDownMessageParam
1337:
1338: //*********************************************************
1339: // IsValidInitMenuPopupMessageParam - WM_INITMENUPOPUP
1340: // ポップアップ・メニューがアクティブになる。
1341: // HMENU wParam …… メニューへのハンドル
1342: // UINT LOWORD(lParam) …… 親メニュー座標での 0 からの相対位置
1343: // bool HIWORD(lParam) …… システムメニューであれば 真
1344: //
1345: // 使用例：
1346: // ASSERT( IsValidInitMenuPopupMessageParam( wParam, lParam ) );
1347: //
1348: //*********************************************************
1349: bool
1350: IsValidInitMenuPopupMessageParam
1351: (
1352: WPARAM wParam,
1353: LPARAM
1354: )
1355: {
1356: VALID_TEST( IsValidMenu( reinterpret_cast<HMENU>( wParam ) ) );
1357:
1358: return true;
1359: }//IsValidInitMenuPopupMessageParam
1360:
1361: //*********************************************************
1362: // IsValidMenu()
1363: // ハンドル hMenu が メニュー であれば 真 を返す。
1364: //
1365: // HMENU hMenu
1366: // メニューのハンドルかどうか調べる ハンドル
1367: //
1368: //*********************************************************
1369: bool // メニューへのハンドル であれば 真
1370: IsValidMenu
1371: (
1372: HMENU hMenu // メニューへのハンドル
1373: )
1374: {
1375: VALID_TEST( hMenu );
1376: VALID_TEST( IsMenu( hMenu ) );
1377:
1378: return true;
1379: }//IsValidMenu
1380:
1381: //*********************************************************
1382: // IsValidMenuSelectMessageParam - WM_MENUSELECT
1383: // メニュー項目の選択状態が変化した
1384: // 選択項目についての説明を表示する
1385: // 常に 0L を返す
1386: // UINT LOWORD(wParam) …… 選択状態にあるメニュー項目の識別子
1387: // 選択項目がサブメニューである場合は親メニュー中の 0 基準位置
1388: // UINT HIWORD(wParam) …… 選択状態にあるメニュー項目の種類の組み合わせ
1389: // メニューが閉じられた場合には 0xFFFF が設定される
1390: // メニューがマウスで選択された場合には MF_MOUSESELECT が追加設定される
1391: // MF_CHECKED, MF_POPUP, MF_SYSMENU, MF_MENUBARBREAK, ...
1392: // HMENU lParam …… 選択項目がサブメニューである場合はサブメニューの親メニューのハンドル
1393: // メニューが閉じられた場合には null が設定される
1394: //
1395: // 使用例：
1396: // ASSERT( IsValidMenuSelectMessageParam( wParam, lParam ) );
1397: //
1398: //*********************************************************
1399: bool
1400: IsValidMenuSelectMessageParam
1401: (
1402: WPARAM wParam,
1403: LPARAM lParam
1404: )
1405: {
1406: const UINT uItem = static_cast<UINT>( LOWORD( wParam ) );
1407: const UINT uFlags = static_cast<UINT>( HIWORD( wParam ) );
1408: HMENU hMenu = reinterpret_cast<HMENU>( lParam );
1409:
1410: VALID_TEST( ( 0xFFFF == uFlags)
1411: || (MF_POPUP != (MF_POPUP & uFlags))
1412: || (IsValidMenu( hMenu ) && IsValidMenu( GetSubMenu( hMenu, uItem) ) ) );
1413:
1414: return true;
1415: }//IsValidMenuSelectMessageParam
1416:
1417: //*********************************************************
1418: // IsValidMenuString()
1419: // メニュー項目 に指定できる 文字列 かどうか調べる。
1420: // メニュー項目 の 文字列 として使えれば 真 を返す。
1421: //
1422: // const char *string
1423: // メニュー項目に指定したい文字列
1424: //
1425: //*********************************************************
1426: bool // 妥当であれば 真
1427: IsValidMenuString
1428: (
1429: const char *string // 文字列
1430: )
1431: {
1432: VALID_TEST( string );
1433: VALID_TEST( IsValidStringPtr( string ) );
1434:
1435: return true;
1436: }//IsValidMenuString
1437:
1438: //*********************************************************
1439: // IsValidNotifyMessageParam - WM_NOTIFY
1440: // 子ウィンドウから通知メッセージを受け取った
1441: // 返値の意味は通知メッセージの種類による
1442: // int wParam …… メッセージを通知してきたウィンドウの識別子
1443: // NMHDR *lParam …… 通知メッセージ構造体へのポインタ
1444: //
1445: // 使用例：
1446: // ASSERT( IsValidNotifyMessageParam( wParam, lParam ) );
1447: //
1448: //*********************************************************
1449: bool
1450: IsValidNotifyMessageParam
1451: (
1452: WPARAM wParam,
1453: LPARAM lParam
1454: )
1455: {
1456: NMHDR *nmhdr = reinterpret_cast<NMHDR *>( lParam );
1457: VALID_TEST( IsValidPtr( nmhdr, sizeof( *nmhdr ) ) );
1458: VALID_TEST( !nmhdr->hwndFrom || IsValidWindow( nmhdr->hwndFrom ) );
1459: VALID_TEST( wParam == nmhdr->idFrom );
1460:
1461: return true;
1462: }//IsValidNotifyMessageParam
1463:
1464: //*********************************************************
1465: // IsValidSetCursorMessageParam - WM_SETCURSOR
1466: // カーソルが移動するたびに呼び出される。
1467: // カーソルを変更する場合は 真 を返す。
1468: // HWND wParam …… ウィンドウのハンドル
1469: // LOWORD(lParam) …… HITTEST コード。
1470: // HTCLIENT, HTCAPTION, HTMENU, ...
1471: // HIWORD(lParam) …… ??? Specifies the identifier of the mouse message.
1472: //
1473: // 使用例：
1474: // ASSERT( IsValidSetCursorMessageParam( wParam, lParam ) );
1475: //
1476: //*********************************************************
1477: bool
1478: IsValidSetCursorMessageParam
1479: (
1480: WPARAM wParam,
1481: LPARAM
1482: )
1483: {
1484: VALID_TEST( IsValidWindow( reinterpret_cast<HWND>( wParam ) ) );
1485:
1486: return true;
1487: }//IsValidSetCursorMessageParam
1488:
1489: //*********************************************************
1490: // IsValidSystemCommandMessageParam - WM_SYSCOMMAND
1491: // システムメニューの項目が選択された
1492: // 返値の意味は選択された項目の種類による
1493: // wParam …… 選択されたメニュー項目の識別子
1494: // SC_CLOSE, SC_CONTEXTHELP, SC_DEFAULT, SC_HOTKEY,
1495: // SC_KEYMENU, SC_MOVE, SC_MONITORPOWER,
1496: // SC_MAXIMIZE, SC_MINIMIZE, SC_MOUSEMENU,
1497: // SC_NEXTWINDOW, SC_PREVWINDOW, SC_HSCROLL, SC_VSCROLL,
1498: // SC_RESTORE, SC_SCREENSAVE, SC_SIZE, SC_TASKLIST, ...
1499: // GET_X_LPARAM(lParam) …… カーソルのスクリーン x 座標
1500: // GET_Y_LPARAM(lParam) …… カーソルのスクリーン y 座標
1501: //
1502: // 使用例：
1503: // ASSERT( IsValidSystemCommandMessageParam( wParam, lParam ) );
1504: //
1505: //*********************************************************
1506: bool
1507: IsValidSystemCommandMessageParam
1508: (
1509: WPARAM ,
1510: LPARAM
1511: )
1512: {
1513: return true;
1514: }//IsValidSystemCommandMessageParam
1515:
1516: //*********************************************************
1517: // IsValidWindow
1518: // ハンドル hWnd がウィンドウとして有効であれば真を返す
1519: //*********************************************************
1520: bool
1521: IsValidWindow
1522: (
1523: HWND hWnd
1524: )
1525: {
1526: VALID_TEST( hWnd );
1527: VALID_TEST( IsWindow( hWnd ) );
1528:
1529: return true;
1530: }//IsValidWindow
1531:
1532: //*********************************************************
1533: // IsValidWindowClass
1534: //*********************************************************
1535: bool
1536: IsValidWindowClass
1537: (
1538: const WNDCLASSEX *wc
1539: )
1540: {
1541: VALID_TEST( wc );
1542: VALID_TEST( IsValidReadPtr( wc, sizeof( *wc ) ) );
1543: VALID_TEST( sizeof( *wc ) == wc->cbSize );
1544: VALID_TEST( IsValidInstanceHandle( wc->hInstance ) );
1545: VALID_TEST( IsValidCodePtr( wc->lpfnWndProc ) );
1546: VALID_TEST( IsValidStringPtr( wc->lpszClassName ) );
1547: VALID_TEST( !wc->lpszMenuName || IsValidResourceName( wc->lpszMenuName ) );
1548: VALID_TEST( !wc->hIcon || IsValidIconHandle( wc->hIcon ) );
1549: VALID_TEST( !wc->hIconSm || IsValidIconHandle( wc->hIconSm ) );
1550: VALID_TEST( !wc->hCursor || IsValidCursorHandle( wc->hCursor ) );
1551:
1552: return true;
1553: }//IsValidWindowClass
1554:
1555: //*********************************************************
1556: // IsValidWindowPosChangingMessageParam - WM_WINDOWPOSCHANGING
1557: // ウィンドウの位置情報が変更されようとしている
1558: // 常に 0L を返す
1559: // WINDOWPOS *lParam …… WINDOWPOS 構造体へのポインタ
1560: //
1561: // 使用例：
1562: // ASSERT( IsValidWindowPosChangingMessageParam( wParam, lParam ) );
1563: //
1564: //*********************************************************
1565: bool
1566: IsValidWindowPosChangingMessageParam
1567: (
1568: WPARAM ,
1569: LPARAM lParam
1570: )
1571: {
1572: WINDOWPOS *wp = reinterpret_cast<WINDOWPOS *>( lParam );
1573: VALID_TEST( IsValidPtr( wp, sizeof( *wp ) ) );
1574:
1575: return true;
1576: }//IsValidWindowPosChangingMessageParam
1577:
1578: //*********************************************************
1579: // IsWindowNotifyMessageParam
1580: //*********************************************************
1581: bool
1582: IsWindowNotifyMessageParam
1583: (
1584: HWND hWnd,
1585: LPARAM lParam
1586: )
1587: {
1588: // パラメタの仮定
1589: ASSERT( IsValidWindow( hWnd ) );
1590: ASSERT( IsValidPtr( (NMHDR *)lParam, sizeof( NMHDR ) ) );
1591:
1592: const NMHDR *nmhdr = GetNotifyMessageParam( lParam );
1593:
1594: if ( nmhdr->hwndFrom != hWnd )
1595: return false;
1596:
1597: if ( nmhdr->idFrom != (UINT)GetDlgCtrlID( hWnd ) )
1598: return false;
1599:
1600: return true;
1601: }//IsWindowNotifyMessageParam
1602:
1603: //*********************************************************
1604: // IsWindowTopmost
1605: // ウィンドウ hWnd が最前面ウィンドウであれば真を返す
1606: //*********************************************************
1607: bool
1608: IsWindowTopmost
1609: (
1610: HWND hWnd
1611: )
1612: {
1613: // パラメタの仮定
1614: ASSERT( IsValidWindow( hWnd ) );
1615:
1616: const DWORD dwWindowExStyle = GetWindowExStyle( hWnd );
1617: return WS_EX_TOPMOST == (WS_EX_TOPMOST & dwWindowExStyle);
1618: }//IsWindowTopmost
1619:
1620:
1621: //------------------------------------------------------------------------------------------------------------------
1622: // j
1623: //------------------------------------------------------------------------------------------------------------------
1624:
1625: //------------------------------------------------------------------------------------------------------------------
1626: // k
1627: //------------------------------------------------------------------------------------------------------------------
1628:
1629: //------------------------------------------------------------------------------------------------------------------
1630: // l
1631: //------------------------------------------------------------------------------------------------------------------
1632:
1633: //------------------------------------------------------------------------------------------------------------------
1634: // m
1635: //------------------------------------------------------------------------------------------------------------------
1636: //*********************************************************
1637: // MakeNotifyStruct
1638: //*********************************************************
1639: bool
1640: MakeNotifyStruct
1641: (
1642: NMHDR *hdr,
1643: HWND hWnd,
1644: UINT code
1645: )
1646: {
1647: // パラメタの仮定
1648: ASSERT( IsValidWindow( hWnd ) );
1649: ASSERT( IsValidPtr( hdr, sizeof( *hdr ) ) );
1650:
1651: memzero( hdr, sizeof( *hdr ) );
1652: hdr->code = code;
1653: hdr->hwndFrom = hWnd;
1654: hdr->idFrom = GetDlgCtrlID( hWnd );
1655: return true;
1656: }//MakeNotifyStruct
1657:
1658: //*********************************************************
1659: // MakeWindowClass
1660: //*********************************************************
1661: bool
1662: MakeWindowClass
1663: (
1664: WNDCLASSEX *wc,
1665: HINSTANCE hInstance,
1666: WNDPROC WndProc,
1667: const char *ClassName,
1668: const char *MenuName,
1669: UINT style
1670: )
1671: {
1672: // パラメタの仮定
1673: ASSERT( IsValidPtr( wc, sizeof( *wc ) ) );
1674: ASSERT( IsValidInstanceHandle( hInstance ) );
1675: ASSERT( IsValidCodePtr( WndProc ) );
1676: ASSERT( IsValidStringPtr( ClassName ) );
1677: ASSERT( !MenuName || IsValidResourceName( MenuName ) );
1678:
1679: // ウィンドウクラスの登録
1680: memzero( wc, sizeof( *wc ) );
1681: wc->cbSize = sizeof( *wc ); // 構造体のサイズ
1682: wc->hInstance = hInstance; // インスタンス
1683: wc->lpszClassName = ClassName; // クラス名
1684: wc->lpfnWndProc = WndProc; // ウィンドウ・メッセージ関数
1685: wc->style = style; // スタイル
1686: wc->lpszMenuName = MenuName; // メニュー
1687: wc->hbrBackground = null; // 背景色
1688: wc->hIcon = null; // 大きいアイコン
1689: wc->hIconSm = null; // 小さいアイコン
1690: wc->hCursor = null; // カーソル
1691: wc->cbClsExtra = 0; //
1692: wc->cbWndExtra = 0; //
1693:
1694: ASSERT( IsValidWindowClass( wc ) );
1695: return true;
1696: }//MakeWindowClass
1697:
1698: //*********************************************************
1699: // MaximizeWindow
1700: // ウィンドウ hWnd を最大化する
1701: // ウィンドウが以前に表示されていた場合には非 0 が返る
1702: // ウィンドウが以前に非表示にされていた場合には 0 が返る
1703: //*********************************************************
1704: bool
1705: MaximizeWindow
1706: (
1707: HWND hWnd
1708: )
1709: {
1710: // パラメタの仮定
1711: ASSERT( IsValidWindow( hWnd ) );
1712:
1713: return !! ShowWindow( hWnd, SW_MAXIMIZE );
1714: }//MaximizeWindow
1715:
1716: //*********************************************************
1717: // Menu_AppendSeparator()
1718: // メニューの末尾に 区切り線 を追加する。
1719: // 区切り線の追加に成功すれば 真 を返す。
1720: //
1721: // HMENU hMenu
1722: // 区切り線を追加する メニュー のハンドル
1723: //
1724: //*********************************************************
1725: bool // 成功すれば 真
1726: Menu_AppendSeparator
1727: (
1728: HMENU hMenu // 区切り線を追加するメニュー
1729: )
1730: {
1731: // パラメタの仮定
1732: ASSERT( IsValidMenu( hMenu ) );
1733:
1734: return !! AppendMenu( hMenu, MFT_SEPARATOR, 0, "" );
1735: }//Menu_AppendSeparator
1736:
1737: //*********************************************************
1738: // Menu_CheckItem()
1739: // メニュー項目 の チェック状態 を変更する。
1740: // 変更前のチェック状態 (MF_CHECKED or MF_UNCHECKED) を返す。
1741: // 指定された メニュー項目 が無い場合は 0xFFFFFFFF を返す。
1742: //
1743: // HMENU hMenu
1744: // 変更対象のメニュー項目を持つ 親メニュー のハンドル
1745: //
1746: // UINT uID
1747: // flags が MF_BYCOMMAND の場合
1748: // チェック状態を変更するメニュー項目の 項目識別子
1749: // flags が MF_BYPOSITION の場合
1750: // チェック状態を変更するメニュー項目の 0 開始位置
1751: //
1752: // UINT flags
1753: // uID の意味を指定する。
1754: // MF_BYCOMMAND or MF_BYPOSITION
1755: //
1756: // bool bCheck
1757: // メニュー項目 にチェックをする場合は 真 を指定する。
1758: //
1759: //*********************************************************
1760: DWORD // 直前の状態
1761: Menu_CheckItem
1762: (
1763: HMENU hMenu, // 親メニューのハンドル
1764: UINT uID, // メニュー項目の 識別子 or 位置
1765: UINT flags, // MF_BYCOMMAND or MF_BYPOSITION
1766: bool bCheck // チェックをする場合は 真
1767: )
1768: {
1769: // パラメタの仮定
1770: ASSERT( IsValidMenu( hMenu ) );
1771: ASSERT( INVALID_MENUITEMID != uID );
1772: ASSERT( (MF_BYCOMMAND == flags)
1773: || (MF_BYPOSITION == flags) );
1774:
1775: const UINT uCheck = ( bCheck ? MF_CHECKED : MF_UNCHECKED );
1776: return CheckMenuItem( hMenu, uID, flags | uCheck );
1777: }//Menu_CheckItem
1778:
1779: //*********************************************************
1780: // Menu_EnableItem()
1781: // メニュー項目 の 有効・無効 を変更する。
1782: // 変更前の 有効・無効 を返す。
1783: // 指定された メニュー項目 が無い場合は 偽 を返す。
1784: //
1785: // HMENU hMenu
1786: // 変更対象のメニュー項目を持つ 親メニュー のハンドル
1787: //
1788: // UINT uID
1789: // flags が MF_BYCOMMAND の場合
1790: // メニュー項目の 項目識別子
1791: // flags が MF_BYPOSITION の場合
1792: // メニュー項目の 0 開始位置
1793: //
1794: // UINT flags
1795: // uID の意味を指定する。
1796: // MF_BYCOMMAND or MF_BYPOSITION
1797: //
1798: // bool bEnable
1799: // メニュー項目 を 有効 にする場合は 真 を指定する。
1800: //
1801: //*********************************************************
1802: bool // 直前の状態
1803: Menu_EnableItem
1804: (
1805: HMENU hMenu, // 親メニューのハンドル
1806: UINT uID, // メニュー項目の 識別子 or 位置
1807: UINT flags, // MF_BYCOMMAND or MF_BYPOSITION
1808: bool bEnable // 有効 にする場合は 真
1809: )
1810: {
1811: // パラメタの仮定
1812: ASSERT( IsValidMenu( hMenu ) );
1813: ASSERT( INVALID_MENUITEMID != uID );
1814: ASSERT( (MF_BYCOMMAND == flags)
1815: || (MF_BYPOSITION == flags) );
1816:
1817: const UINT uEnable = ( bEnable ? MF_ENABLED : MF_GRAYED );
1818: return MF_ENABLED == EnableMenuItem( hMenu, uID, flags | uEnable );
1819: }//Menu_EnableItem
1820:
1821: //*********************************************************
1822: // Menu_InsertSeparator()
1823: // メニューに 区切り線 を 挿入 する。
1824: // 区切り線の挿入に成功すれば 真 を返す。
1825: //
1826: // HMENU hMenu
1827: // 区切り線を挿入する メニュー のハンドル
1828: //
1829: // UINT uID
1830: // 区切り線を挿入する位置の直前にある メニュー項目 を指定します。
1831: // flags が MF_BYCOMMAND の場合
1832: // メニュー項目の 項目識別子
1833: // flags が MF_BYPOSITION の場合
1834: // メニュー項目の 0 開始位置
1835: //
1836: // UINT flags
1837: // uID の意味を指定する。
1838: // MF_BYCOMMAND or MF_BYPOSITION
1839: //
1840: //*********************************************************
1841: bool // 成功すれば 真
1842: Menu_InsertSeparator
1843: (
1844: HMENU hMenu, // 区切り線を挿入するメニュー
1845: UINT uID, // 挿入位置直前の メニュー項目
1846: UINT flags // MF_BYCOMMAND or MF_BYPOSITION
1847: )
1848: {
1849: // パラメタの仮定
1850: ASSERT( IsValidMenu( hMenu ) );
1851: ASSERT( INVALID_MENUITEMID != uID );
1852: ASSERT( (MF_BYCOMMAND == flags)
1853: || (MF_BYPOSITION == flags) );
1854:
1855: return !! InsertMenu( hMenu, uID, MFT_SEPARATOR | flags, 0, "" );
1856: }//Menu_InsertSeparator
1857:
1858: //*********************************************************
1859: // MinimizeWindow
1860: // ウィンドウ hWnd を最小化する
1861: // Ｚ順位が次のトップレベルウィンドウをアクティブにする
1862: // ウィンドウが以前に表示されていた場合には非 0 が返る
1863: // ウィンドウが以前に非表示にされていた場合には 0 が返る
1864: //*********************************************************
1865: bool
1866: MinimizeWindow
1867: (
1868: HWND hWnd
1869: )
1870: {
1871: // パラメタの仮定
1872: ASSERT( IsValidWindow( hWnd ) );
1873:
1874: return !! ShowWindow( hWnd, SW_MINIMIZE );
1875: }//MinimizeWindow
1876:
1877:
1878: //------------------------------------------------------------------------------------------------------------------
1879: // n
1880: //------------------------------------------------------------------------------------------------------------------
1881:
1882: //------------------------------------------------------------------------------------------------------------------
1883: // o
1884: //------------------------------------------------------------------------------------------------------------------
1885:
1886: //------------------------------------------------------------------------------------------------------------------
1887: // p
1888: //------------------------------------------------------------------------------------------------------------------
1889: //*********************************************************
1890: // PopupMenu()
1891: // メニューをポップアップ表示する。
1892: // 関数が成功すれば 真 を返す。
1893: //
1894: // HWND hwndOwner
1895: // メッセージを受け取る ウィンドウ のハンドル
1896: //
1897: // HMENU hMenuPopup
1898: // 表示するメニューのハンドル
1899: //
1900: // const POINT *pt
1901: // メニューを表示する スクリーン座標
1902: //
1903: // UINT flags
1904: // TPM_RIGHTBUTTON, TPM_RECURSE, TPM_VERTICAL, ...
1905: //
1906: // [参照]
1907: // PopupMenu()
1908: // PopupMenuEx()
1909: // PopupMenuCursorPos()
1910: // PopupMenuCursorPosEx()
1911: // PopupSubMenu()
1912: // PopupSubMenuEx()
1913: // PopupSubMenuCursorPos()
1914: // PopupSubMenuCursorPosEx()
1915: //
1916: //*********************************************************
1917: bool // 成功すれば 真
1918: PopupMenu
1919: (
1920: HWND hwndOwner, // メッセージを受け取る ウィンドウ
1921: HMENU hMenuPopup, // 表示するメニュー
1922: const POINT *pt, // メニューを表示する スクリーン座標
1923: UINT flags // 関数オプションの組み合わせ
1924: )
1925: {
1926: // パラメタの仮定
1927: ASSERT( IsValidWindow( hwndOwner ) );
1928: ASSERT( IsValidMenu( hMenuPopup ) );
1929: ASSERT( IsValidReadPtr( pt, sizeof( *pt ) ) );
1930: ASSERT( TPM_RETURNCMD != (TPM_RETURNCMD & flags) );
1931:
1932: return PopupMenuEx
1933: (
1934: hwndOwner,
1935: hMenuPopup,
1936: pt,
1937: flags,
1938: null
1939: );
1940: }//PopupMenu
1941:
1942: //*********************************************************
1943: // PopupMenuEx()
1944: // メニューをポップアップ表示する。
1945: // 関数が成功すれば 真 を返す。
1946: //
1947: // HWND hwndOwner
1948: // メッセージを受け取る ウィンドウ のハンドル
1949: //
1950: // HMENU hMenuPopup
1951: // 表示するメニューのハンドル
1952: //
1953: // const POINT *pt
1954: // メニューを表示する スクリーン座標
1955: //
1956: // UINT flags
1957: // TPM_RIGHTBUTTON, TPM_RECURSE, TPM_VERTICAL, ...
1958: //
1959: // const RECT *rcClip
1960: // メニューのオーバーラップを回避する領域を指定する。
1961: // そのような領域がない場合は null を指定する。
1962: //
1963: // [参照]
1964: // PopupMenu()
1965: // PopupMenuEx()
1966: // PopupMenuCursorPos()
1967: // PopupMenuCursorPosEx()
1968: // PopupSubMenu()
1969: // PopupSubMenuEx()
1970: // PopupSubMenuCursorPos()
1971: // PopupSubMenuCursorPosEx()
1972: //
1973: //*********************************************************
1974: bool // 成功すれば 真
1975: PopupMenuEx
1976: (
1977: HWND hwndOwner, // メッセージを受け取る ウィンドウ
1978: HMENU hMenuPopup, // 表示するメニュー
1979: const POINT *pt, // メニューを表示する スクリーン座標
1980: UINT flags, // 関数オプションの組み合わせ
1981: const RECT *rcClip // オーバーラップを回避する領域
1982: )
1983: {
1984: // パラメタの仮定
1985: ASSERT( IsValidWindow( hwndOwner ) );
1986: ASSERT( IsValidMenu( hMenuPopup ) );
1987: ASSERT( IsValidReadPtr( pt, sizeof( *pt ) ) );
1988: ASSERT( TPM_RETURNCMD != (TPM_RETURNCMD & flags) );
1989: ASSERT( !rcClip || IsValidRect( rcClip ) );
1990:
1991: // ウィンドウをフォアグラウンドにしないとキーボードでの項目選択に失敗する場合がある。
1992: SetForegroundWindow( hwndOwner );
1993:
1994: //
1995: if ( !rcClip )
1996: {
1997: // 範囲制限なし
1998: return !! TrackPopupMenuEx
1999: (
2000: hMenuPopup,
2001: flags,
2002: pt->x,
2003: pt->y,
2004: hwndOwner,
2005: null
2006: );
2007: }
2008: else
2009: {
2010: // 範囲制限あり
2011: TPMPARAMS tpm;
2012: memzero( &tpm, sizeof( tpm ) );
2013: tpm.cbSize = sizeof( tpm );
2014: VERIFY( CopyRect( &tpm.rcExclude, rcClip ) );
2015: return !! TrackPopupMenuEx
2016: (
2017: hMenuPopup,
2018: flags,
2019: pt->x,
2020: pt->y,
2021: hwndOwner,
2022: &tpm
2023: );
2024: }
2025: }//PopupMenuEx
2026:
2027: //*********************************************************
2028: // PopupMenuCursorPos()
2029: // カーソル位置 にメニューをポップアップ表示する。
2030: // 関数が成功すれば 真 を返す。
2031: //
2032: // HWND hwndOwner
2033: // メッセージを受け取る ウィンドウ のハンドル
2034: //
2035: // HMENU hMenuPopup
2036: // 表示するメニューのハンドル
2037: //
2038: // UINT flags
2039: // TPM_RIGHTBUTTON, TPM_RECURSE, TPM_VERTICAL, ...
2040: //
2041: // [参照]
2042: // PopupMenu()
2043: // PopupMenuEx()
2044: // PopupMenuCursorPos()
2045: // PopupMenuCursorPosEx()
2046: // PopupSubMenu()
2047: // PopupSubMenuEx()
2048: // PopupSubMenuCursorPos()
2049: // PopupSubMenuCursorPosEx()
2050: //
2051: //*********************************************************
2052: bool // 成功すれば 真
2053: PopupMenuCursorPos
2054: (
2055: HWND hwndOwner, // メッセージを受け取る ウィンドウ
2056: HMENU hMenuPopup, // 表示するメニュー
2057: UINT flags // 関数オプションの組み合わせ
2058: )
2059: {
2060: // パラメタの仮定
2061: ASSERT( IsValidWindow( hwndOwner ) );
2062: ASSERT( IsValidMenu( hMenuPopup ) );
2063: ASSERT( TPM_RETURNCMD != (TPM_RETURNCMD & flags) );
2064:
2065: return PopupMenuCursorPosEx
2066: (
2067: hwndOwner,
2068: hMenuPopup,
2069: flags,
2070: null
2071: );
2072: }//PopupMenuCursorPos
2073:
2074: //*********************************************************
2075: // PopupMenuCursorPosEx()
2076: // カーソル位置 にメニューをポップアップ表示する。
2077: // 関数が成功すれば 真 を返す。
2078: //
2079: // HWND hwndOwner
2080: // メッセージを受け取る ウィンドウ のハンドル
2081: //
2082: // HMENU hMenuPopup
2083: // 表示するメニューのハンドル
2084: //
2085: // UINT flags
2086: // TPM_RIGHTBUTTON, TPM_RECURSE, TPM_VERTICAL, ...
2087: //
2088: // const RECT *rcClip
2089: // メニューのオーバーラップを回避する領域を指定する。
2090: // そのような領域がない場合は null を指定する。
2091: //
2092: // [参照]
2093: // PopupMenu()
2094: // PopupMenuEx()
2095: // PopupMenuCursorPos()
2096: // PopupMenuCursorPosEx()
2097: // PopupSubMenu()
2098: // PopupSubMenuEx()
2099: // PopupSubMenuCursorPos()
2100: // PopupSubMenuCursorPosEx()
2101: //
2102: //*********************************************************
2103: bool // 成功すれば 真
2104: PopupMenuCursorPosEx
2105: (
2106: HWND hwndOwner, // メッセージを受け取る ウィンドウ
2107: HMENU hMenuPopup, // 表示するメニュー
2108: UINT flags, // 関数オプションの組み合わせ
2109: const RECT *rcClip // オーバーラップを回避する領域
2110: )
2111: {
2112: // パラメタの仮定
2113: ASSERT( IsValidWindow( hwndOwner ) );
2114: ASSERT( IsValidMenu( hMenuPopup ) );
2115: ASSERT( TPM_RETURNCMD != (TPM_RETURNCMD & flags) );
2116: ASSERT( !rcClip || IsValidRect( rcClip ) );
2117:
2118: // メニューの表示位置を取得する。
2119: POINT ptCursor;
2120: if ( !GetCursorPos( &ptCursor ) )
2121: {
2122: return false; // 関数が失敗した場合は 偽 を返す。
2123: }
2124:
2125: return PopupMenuEx
2126: (
2127: hwndOwner,
2128: hMenuPopup,
2129: &ptCursor,
2130: flags,
2131: rcClip
2132: );
2133: }//PopupMenuCursorPosEx
2134:
2135: //*********************************************************
2136: // PopupSubMenu()
2137: // メニュー name の位置 pos にある サブメニュー をポップアップ表示する。
2138: // 関数が成功すれば 真 を返す。
2139: //
2140: // HINSTANCE hInstance
2141: // メニューリソース を持つ モジュール
2142: //
2143: // const char *name
2144: // メニュー名
2145: //
2146: // int pos
2147: // サブメニューの 0 開始位置
2148: //
2149: // HWND hwndOwner
2150: // メッセージを受け取る ウィンドウ のハンドル
2151: //
2152: // const POINT *pt
2153: // メニューを表示する スクリーン座標
2154: //
2155: // UINT flags
2156: // TPM_RIGHTBUTTON, TPM_RECURSE, TPM_VERTICAL, ...
2157: //
2158: // [参照]
2159: // PopupMenu()
2160: // PopupMenuEx()
2161: // PopupMenuCursorPos()
2162: // PopupMenuCursorPosEx()
2163: // PopupSubMenu()
2164: // PopupSubMenuEx()
2165: // PopupSubMenuCursorPos()
2166: // PopupSubMenuCursorPosEx()
2167: //
2168: //*********************************************************
2169: bool // 成功すれば 真
2170: PopupSubMenu
2171: (
2172: HINSTANCE hInstance, // メニューリソースを持つモジュール
2173: const char *name, // メニュー名
2174: int pos, // サブメニューの 0 開始位置
2175: HWND hwndOwner, // メッセージを受け取る ウィンドウ
2176: const POINT *pt, // メニューを表示する スクリーン座標
2177: UINT flags // 関数オプションの組み合わせ
2178: )
2179: {
2180: // パラメタの仮定
2181: ASSERT( IsValidInstanceHandle( hInstance ) );
2182: ASSERT( IsValidResourceName( name ) );
2183: ASSERT( 0 <= pos );
2184: ASSERT( IsValidWindow( hwndOwner ) );
2185: ASSERT( IsValidReadPtr( pt, sizeof( *pt ) ) );
2186: ASSERT( TPM_RETURNCMD != (TPM_RETURNCMD & flags) );
2187:
2188: return PopupSubMenuEx
2189: (
2190: hInstance,
2191: name,
2192: pos,
2193: hwndOwner,
2194: pt,
2195: flags,
2196: null
2197: );
2198: }//PopupSubMenu
2199:
2200: //*********************************************************
2201: // PopupSubMenuEx()
2202: // メニュー name の位置 pos にある サブメニュー をポップアップ表示する。
2203: // 関数が成功すれば 真 を返す。
2204: //
2205: // HINSTANCE hInstance
2206: // メニューリソース を持つ モジュール
2207: //
2208: // const char *name
2209: // メニュー名
2210: //
2211: // int pos
2212: // サブメニューの 0 開始位置
2213: //
2214: // HWND hwndOwner
2215: // メッセージを受け取る ウィンドウ のハンドル
2216: //
2217: // const POINT *pt
2218: // メニューを表示する スクリーン座標
2219: //
2220: // UINT flags
2221: // TPM_RIGHTBUTTON, TPM_RECURSE, TPM_VERTICAL, ...
2222: //
2223: // const RECT *rcClip
2224: // メニューのオーバーラップを回避する領域を指定する。
2225: // そのような領域がない場合は null を指定する。
2226: //
2227: // [参照]
2228: // PopupMenu()
2229: // PopupMenuEx()
2230: // PopupMenuCursorPos()
2231: // PopupMenuCursorPosEx()
2232: // PopupSubMenu()
2233: // PopupSubMenuEx()
2234: // PopupSubMenuCursorPos()
2235: // PopupSubMenuCursorPosEx()
2236: //
2237: //*********************************************************
2238: bool // 成功すれば 真
2239: PopupSubMenuEx
2240: (
2241: HINSTANCE hInstance, // メニューリソースを持つモジュール
2242: const char *name, // メニュー名
2243: int pos, // サブメニューの 0 開始位置
2244: HWND hwndOwner, // メッセージを受け取る ウィンドウ
2245: const POINT *pt, // メニューを表示する スクリーン座標
2246: UINT flags, // 関数オプションの組み合わせ
2247: const RECT *rcClip // オーバーラップを回避する領域
2248: )
2249: {
2250: // パラメタの仮定
2251: ASSERT( IsValidInstanceHandle( hInstance ) );
2252: ASSERT( IsValidResourceName( name ) );
2253: ASSERT( 0 <= pos );
2254: ASSERT( IsValidWindow( hwndOwner ) );
2255: ASSERT( IsValidReadPtr( pt, sizeof( *pt ) ) );
2256: ASSERT( TPM_RETURNCMD != (TPM_RETURNCMD & flags) );
2257: ASSERT( !rcClip || IsValidRect( rcClip ) );
2258:
2259: // トップレベルメニュー のロード
2260: HMENU hTopMenu = LoadMenu( hInstance, name );
2261: if ( !hTopMenu )
2262: {
2263: return false; // トップレベルメニュー のロードに失敗
2264: }
2265:
2266: // サブメニュー のロード
2267: HMENU hMenuPopup = GetSubMenu( hTopMenu, pos );
2268: if ( !hMenuPopup )
2269: {
2270: VERIFY( DestroyMenu( hTopMenu ) );
2271: return false; // サブメニュー のロードに失敗
2272: }
2273:
2274: //
2275: ASSERT( IsValidMenu( hTopMenu ) );
2276: ASSERT( IsValidMenu( hMenuPopup ) );
2277: ASSERT( pos < GetMenuItemCount( hTopMenu ) );
2278:
2279: //
2280: const bool bSuccess = PopupMenuEx
2281: (
2282: hwndOwner,
2283: hMenuPopup,
2284: pt,
2285: flags,
2286: rcClip
2287: );
2288:
2289: //
2290: VERIFY( DestroyMenu( hTopMenu ) );
2291:
2292: return bSuccess;
2293: }//PopupSubMenuEx
2294:
2295: //*********************************************************
2296: // PopupSubMenuCursorPos()
2297: // メニュー name の位置 pos にある サブメニューを カーソル位置 にポップアップ表示する。
2298: // 関数が成功すれば 真 を返す。
2299: //
2300: // HINSTANCE hInstance
2301: // メニューリソース を持つ モジュール
2302: //
2303: // const char *name
2304: // メニュー名
2305: //
2306: // int pos
2307: // サブメニューの 0 開始位置
2308: //
2309: // HWND hwndOwner
2310: // メッセージを受け取る ウィンドウ のハンドル
2311: //
2312: // UINT flags
2313: // TPM_RIGHTBUTTON, TPM_RECURSE, TPM_VERTICAL, ...
2314: //
2315: // [参照]
2316: // PopupMenu()
2317: // PopupMenuEx()
2318: // PopupMenuCursorPos()
2319: // PopupMenuCursorPosEx()
2320: // PopupSubMenu()
2321: // PopupSubMenuEx()
2322: // PopupSubMenuCursorPos()
2323: // PopupSubMenuCursorPosEx()
2324: //
2325: //*********************************************************
2326: bool // 成功すれば 真
2327: PopupSubMenuCursorPos
2328: (
2329: HINSTANCE hInstance, // メニューリソースを持つモジュール
2330: const char *name, // メニュー名
2331: int pos, // サブメニューの 0 開始位置
2332: HWND hwndOwner, // メッセージを受け取る ウィンドウ
2333: UINT flags // 関数オプションの組み合わせ
2334: )
2335: {
2336: // パラメタの仮定
2337: ASSERT( IsValidInstanceHandle( hInstance ) );
2338: ASSERT( IsValidResourceName( name ) );
2339: ASSERT( 0 <= pos );
2340: ASSERT( IsValidWindow( hwndOwner ) );
2341: ASSERT( TPM_RETURNCMD != (TPM_RETURNCMD & flags) );
2342:
2343: return PopupSubMenuCursorPosEx
2344: (
2345: hInstance,
2346: name,
2347: pos,
2348: hwndOwner,
2349: flags,
2350: null
2351: );
2352: }//PopupSubMenuCursorPos
2353:
2354: //*********************************************************
2355: // PopupSubMenuCursorPosEx()
2356: // メニュー name の位置 pos にある サブメニュー を カーソル位置 にポップアップ表示する。
2357: // 関数が成功すれば 真 を返す。
2358: //
2359: // HINSTANCE hInstance
2360: // メニューリソース を持つ モジュール
2361: //
2362: // const char *name
2363: // メニュー名
2364: //
2365: // int pos
2366: // サブメニューの 0 開始位置
2367: //
2368: // HWND hwndOwner
2369: // メッセージを受け取る ウィンドウ のハンドル
2370: //
2371: // UINT flags
2372: // TPM_RIGHTBUTTON, TPM_RECURSE, TPM_VERTICAL, ...
2373: //
2374: // const RECT *rcClip
2375: // メニューのオーバーラップを回避する領域を指定する。
2376: // そのような領域がない場合は null を指定する。
2377: //
2378: // [参照]
2379: // PopupMenu()
2380: // PopupMenuEx()
2381: // PopupMenuCursorPos()
2382: // PopupMenuCursorPosEx()
2383: // PopupSubMenu()
2384: // PopupSubMenuEx()
2385: // PopupSubMenuCursorPos()
2386: // PopupSubMenuCursorPosEx()
2387: //
2388: //*********************************************************
2389: bool // 成功すれば 真
2390: PopupSubMenuCursorPosEx
2391: (
2392: HINSTANCE hInstance, // メニューリソースを持つモジュール
2393: const char *name, // メニュー名
2394: int pos, // サブメニューの 0 開始位置
2395: HWND hwndOwner, // メッセージを受け取る ウィンドウ
2396: UINT flags, // 関数オプションの組み合わせ
2397: const RECT *rcClip // オーバーラップを回避する領域
2398: )
2399: {
2400: // パラメタの仮定
2401: ASSERT( IsValidInstanceHandle( hInstance ) );
2402: ASSERT( IsValidResourceName( name ) );
2403: ASSERT( 0 <= pos );
2404: ASSERT( IsValidWindow( hwndOwner ) );
2405: ASSERT( TPM_RETURNCMD != (TPM_RETURNCMD & flags) );
2406: ASSERT( !rcClip || IsValidRect( rcClip ) );
2407:
2408: // メニューの表示位置を取得する。
2409: POINT ptCursor;
2410: if ( !GetCursorPos( &ptCursor ) )
2411: {
2412: return false; // 関数が失敗した場合は 偽 を返す。
2413: }
2414:
2415: return PopupSubMenuEx
2416: (
2417: hInstance,
2418: name,
2419: pos,
2420: hwndOwner,
2421: &ptCursor,
2422: flags,
2423: rcClip
2424: );
2425: }//PopupSubMenuCursorPosEx
2426:
2427:
2428: //------------------------------------------------------------------------------------------------------------------
2429: // q
2430: //------------------------------------------------------------------------------------------------------------------
2431:
2432: //------------------------------------------------------------------------------------------------------------------
2433: // r
2434: //------------------------------------------------------------------------------------------------------------------
2435: //*********************************************************
2436: // ResetWindowTopmost
2437: //*********************************************************
2438: bool
2439: ResetWindowTopmost
2440: (
2441: HWND hWnd
2442: )
2443: {
2444: // パラメタの仮定
2445: ASSERT( IsValidWindow( hWnd ) );
2446:
2447: return !! SetWindowPos
2448: (
2449: hWnd,
2450: HWND_NOTOPMOST,
2451: 0,
2452: 0,
2453: 0,
2454: 0,
2455: SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOSENDCHANGING
2456: );
2457: }//ResetWindowTopmost
2458:
2459: //*********************************************************
2460: // RestoreWindow
2461: // ウィンドウ hWnd をアクティブにして元の位置とサイズに復元する
2462: // ウィンドウが以前に表示されていた場合には非 0 が返る
2463: // ウィンドウが以前に非表示にされていた場合には 0 が返る
2464: //*********************************************************
2465: bool
2466: RestoreWindow
2467: (
2468: HWND hWnd
2469: )
2470: {
2471: // パラメタの仮定
2472: ASSERT( IsValidWindow( hWnd ) );
2473:
2474: return !! ShowWindow( hWnd, SW_RESTORE );
2475: }//RestoreWindow
2476:
2477:
2478: //------------------------------------------------------------------------------------------------------------------
2479: // s
2480: //------------------------------------------------------------------------------------------------------------------
2481: //*********************************************************
2482: // ScreenRectToClientRect
2483: // スクリーン座標の矩形 rc をクライアント座標に変換する
2484: //*********************************************************
2485: bool
2486: ScreenRectToClientRect
2487: (
2488: HWND hWnd,
2489: RECT *rc
2490: )
2491: {
2492: // パラメタの仮定
2493: ASSERT( IsValidWindow( hWnd ) );
2494: ASSERT( IsValidPtr( rc, sizeof( *rc ) ) );
2495: ASSERT( IsValidRect( rc ) );
2496:
2497: POINT pt = { 0, 0 };
2498: if ( !ScreenToClient( hWnd, &pt ) )
2499: return false;
2500:
2501: VERIFY( OffsetRect( rc, pt.x , pt.y ) );
2502: ASSERT( IsValidRect( rc ) );
2503: return true;
2504: }//ScreenRectToClientRect
2505:
2506: //*********************************************************
2507: // ScreenToWindow
2508: // スクリーン座標 pt をウィンドウ座標に変換する
2509: //*********************************************************
2510: bool
2511: ScreenToWindow
2512: (
2513: HWND hWnd,
2514: POINT *pt
2515: )
2516: {
2517: // パラメタの仮定
2518: ASSERT( IsValidWindow( hWnd ) );
2519: ASSERT( IsValidPtr( pt, sizeof( *pt ) ) );
2520:
2521: POINT ptWindow;
2522: VERIFY( GetWindowPoint( hWnd, &ptWindow ) );
2523: VERIFY( OffsetPoint( pt, -ptWindow.x, -ptWindow.y ) );
2524: return true;
2525: }//ScreenToWindow
2526:
2527: //*********************************************************
2528: // SendNotifyCommand
2529: //*********************************************************
2530: LRESULT
2531: SendNotifyCommand
2532: (
2533: HWND hCtrl,
2534: WORD wNotifyCode
2535: )
2536: {
2537: // パラメタの仮定
2538: ASSERT( IsValidWindow( hCtrl ) );
2539: ASSERT( IsValidWindow( GetParent(hCtrl) ) );
2540: ASSERT( 1 < (WORD)GetWindowID( hCtrl ) ); // 0 〜 1 はメニューやホットキーを表す
2541:
2542: WORD wID = (WORD)GetWindowID( hCtrl );
2543: HWND hParent = GetParent( hCtrl );
2544: return SendMessage
2545: (
2546: hParent,
2547: WM_COMMAND,
2548: MAKEWPARAM(wID, wNotifyCode),
2549: (LPARAM)hCtrl
2550: );
2551: }//SendNotifyCommand
2552:
2553: //*********************************************************
2554: // SetClassBrush
2555: // WHITE_BRUSH, LTGRAY_BRUSH, GRAY_BRUSH, DKGRAY_BRUSH,
2556: // BLACK_BRUSH, NULL_BRUSH, HOLLOW_BRUSH
2557: //*********************************************************
2558: HBRUSH
2559: SetClassBrush
2560: (
2561: HWND hWnd,
2562: HBRUSH hBrush
2563: )
2564: {
2565: // パラメタの仮定
2566: ASSERT( IsValidWindow( hWnd ) );
2567: ASSERT( IsValidBrushHandle( hBrush ) );
2568:
2569: return (HBRUSH)SetClassLongPtr64( hWnd, GCL_HBRBACKGROUND, reinterpret_cast<LONG_PTR>( hBrush ) );
2570: }//SetClassBrush
2571:
2572: //*********************************************************
2573: // SetClassCursor
2574: //*********************************************************
2575: HCURSOR
2576: SetClassCursor
2577: (
2578: HWND hWnd,
2579: HCURSOR hCursor
2580: )
2581: {
2582: // パラメタの仮定
2583: ASSERT( IsValidWindow( hWnd ) );
2584: ASSERT( IsValidCursorHandle( hCursor ) );
2585:
2586: return (HCURSOR)SetClassLongPtr64( hWnd, GCL_HCURSOR, reinterpret_cast<LONG_PTR>( hCursor ) );
2587: }//SetClassCursor
2588:
2589: //*********************************************************
2590: // SetClassIcon
2591: // fType …… ICON_BIG, ICON_SMALL, ...
2592: //*********************************************************
2593: HICON
2594: SetClassIcon
2595: (
2596: HWND hWnd,
2597: WPARAM fType,
2598: HICON hIcon
2599: )
2600: {
2601: // パラメタの仮定
2602: ASSERT( IsValidWindow( hWnd ) );
2603: ASSERT( ( ICON_BIG == fType )
2604: || ( ICON_SMALL == fType ) );
2605: ASSERT( IsValidIconHandle( hIcon ) );
2606:
2607: return (HICON)SetClassLongPtr64
2608: (
2609: hWnd,
2610: ((ICON_BIG == fType) ? GCL_HICON: GCL_HICONSM),
2611: reinterpret_cast<LONG_PTR>( hIcon )
2612: );
2613: }//SetClassIcon
2614:
2615: //*********************************************************
2616: // SetClassStyle
2617: //*********************************************************
2618: DWORD
2619: SetClassStyle
2620: (
2621: HWND hWnd,
2622: DWORD dwStyle
2623: )
2624: {
2625: // パラメタの仮定
2626: ASSERT( IsValidWindow( hWnd ) );
2627:
2628: return (DWORD)SetClassLongPtr64( hWnd, GCL_STYLE, dwStyle );
2629: }//SetClassStyle
2630:
2631: //*********************************************************
2632: // SetDeferWindowSize
2633: //*********************************************************
2634: HDWP
2635: SetDeferWindowSize
2636: (
2637: HDWP *phWinPosInfo,
2638: HWND hWnd,
2639: int Width,
2640: int Height
2641: )
2642: {
2643: // パラメタの仮定
2644: ASSERT( IsValidWindow( hWnd ) );
2645: ASSERT( IsValidPtr( phWinPosInfo, sizeof( *phWinPosInfo ) ) );
2646: ASSERT( *phWinPosInfo );
2647:
2648: *phWinPosInfo = DeferWindowPos( *phWinPosInfo, hWnd, null, 0, 0, Width, Height, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER );
2649: return *phWinPosInfo;
2650: }//SetDeferWindowSize
2651:
2652: //*********************************************************
2653: // SetDlgItemFocus
2654: // ウィンドウ hWnd の識別子 nID を持つ子ウィンドウにフォーカスを設定する
2655: // 以前にフォーカスを持っていたウィンドウへのハンドルを返す
2656: //*********************************************************
2657: HWND
2658: SetDlgItemFocus
2659: (
2660: HWND hWnd,
2661: int nID
2662: )
2663: {
2664: // パラメタの仮定
2665: ASSERT( IsValidWindow( hWnd ) );
2666: ASSERT( IsValidDlgItem( hWnd, nID ) );
2667:
2668: HWND hCtrl = GetDlgItem( hWnd, nID );
2669: return SetFocus( hCtrl );
2670: }//SetDlgItemFocus
2671:
2672: //*********************************************************
2673: // SetMenuString()
2674: // メニュー項目の 文字列 を変更する。
2675: // 文字列の設定に成功すれば 真 を返す。
2676: //
2677: // HMENU hMenu
2678: // 変更対象のメニュー項目を持つ 親メニュー のハンドル
2679: //
2680: // UINT uID
2681: // flags が MF_BYCOMMAND の場合
2682: // メニュー項目の 項目識別子
2683: // flags が MF_BYPOSITION の場合
2684: // メニュー項目の 0 開始位置
2685: //
2686: // UINT flags
2687: // uID の意味を指定する。
2688: // MF_BYCOMMAND or MF_BYPOSITION
2689: //
2690: // const char *string
2691: // メニュー項目に指定する 文字列
2692: //
2693: //*********************************************************
2694: bool // 成功すれば 真
2695: SetMenuString
2696: (
2697: HMENU hMenu, // 親メニューのハンドル
2698: UINT uID, // メニュー項目の 識別子 or 位置
2699: UINT flags, // MF_BYCOMMAND or MF_BYPOSITION
2700: const char *string // 指定する 文字列
2701: )
2702: {
2703: // パラメタの仮定
2704: ASSERT( IsValidMenu( hMenu ) );
2705: ASSERT( INVALID_MENUITEMID != uID );
2706: ASSERT( (MF_BYCOMMAND == flags)
2707: || (MF_BYPOSITION == flags) );
2708: ASSERT( IsValidMenuString( string ) );
2709:
2710: // 項目識別子 を取得する。
2711: const UINT uNewID = ((MF_BYCOMMAND == flags) ? uID : GetMenuItemID(hMenu, uID));
2712: if ( INVALID_MENUITEMID == uNewID )
2713: return false; // 関数が失敗した場合は 偽 を返す。
2714:
2715: // 文字列を変更する
2716: return !! ModifyMenu( hMenu, uID, flags, uNewID, string );
2717: }//SetMenuString
2718:
2719: //*********************************************************
2720: // SetWindowExStyle
2721: //*********************************************************
2722: DWORD
2723: SetWindowExStyle
2724: (
2725: HWND hWnd,
2726: DWORD dwExStyle
2727: )
2728: {
2729: // パラメタの仮定
2730: ASSERT( IsValidWindow( hWnd ) );
2731:
2732: return (DWORD)SetWindowLongPtr64( hWnd, GWL_EXSTYLE, dwExStyle );
2733: }//SetWindowExStyle
2734:
2735: //*********************************************************
2736: // SetWindowIcon
2737: // WPARAM --- ICON_BIG, ICON_SMALL, ...
2738: //*********************************************************
2739: HICON
2740: SetWindowIcon
2741: (
2742: HWND hWnd,
2743: WPARAM fType,
2744: HICON hIcon
2745: )
2746: {
2747: // パラメタの仮定
2748: ASSERT( IsValidWindow( hWnd ) );
2749: ASSERT( (ICON_BIG == fType)
2750: || (ICON_SMALL == fType) );
2751: ASSERT( IsValidIconHandle( hIcon ) );
2752:
2753: return (HICON)SendMessage( hWnd, WM_SETICON, fType, reinterpret_cast<LPARAM>( hIcon ) );
2754: }//SetWindowIcon
2755:
2756: //*********************************************************
2757: // SetWindowPriority
2758: //*********************************************************
2759: bool
2760: SetWindowPriority
2761: (
2762: HWND hWnd,
2763: DWORD dwPriorityClass
2764: )
2765: {
2766: // パラメタの仮定
2767: ASSERT( IsValidWindow( hWnd ) );
2768: ASSERT( ( NORMAL_PRIORITY_CLASS == dwPriorityClass )
2769: || ( IDLE_PRIORITY_CLASS == dwPriorityClass )
2770: || ( HIGH_PRIORITY_CLASS == dwPriorityClass )
2771: || ( REALTIME_PRIORITY_CLASS == dwPriorityClass ) );
2772:
2773: HANDLE hProcess = OpenWindowProcess( hWnd, PROCESS_ALL_ACCESS, false );
2774: if ( !hProcess )
2775: return false;
2776:
2777: VERIFY( SetPriorityClass( hProcess, dwPriorityClass ) );
2778: VERIFY( CloseHandle( hProcess ) );
2779: return true;
2780: }//SetWindowPriority
2781:
2782: //*********************************************************
2783: // SetWindowSize
2784: //*********************************************************
2785: bool
2786: SetWindowSize
2787: (
2788: HWND hWnd,
2789: int nWidth,
2790: int nHeight
2791: )
2792: {
2793: // パラメタの仮定
2794: ASSERT( IsValidWindow( hWnd ) );
2795:
2796: return !! SetWindowPos( hWnd, null, 0, 0, nWidth, nHeight, SWP_NOMOVE|SWP_NOZORDER );
2797: }//SetWindowSize
2798:
2799: //*********************************************************
2800: // SetWindowStyle
2801: //*********************************************************
2802: DWORD
2803: SetWindowStyle
2804: (
2805: HWND hWnd,
2806: DWORD dwStyle
2807: )
2808: {
2809: // パラメタの仮定
2810: ASSERT( IsValidWindow( hWnd ) );
2811:
2812: return (DWORD)SetWindowLongPtr64( hWnd, GWL_STYLE, dwStyle );
2813: }//SetWindowStyle
2814:
2815: //*********************************************************
2816: // SetWindowTopmost
2817: //*********************************************************
2818: bool
2819: SetWindowTopmost
2820: (
2821: HWND hWnd
2822: )
2823: {
2824: // パラメタの仮定
2825: ASSERT( IsValidWindow( hWnd ) );
2826:
2827: return !! SetWindowPos
2828: (
2829: hWnd,
2830: HWND_TOPMOST,
2831: 0,
2832: 0,
2833: 0,
2834: 0,
2835: SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOSENDCHANGING
2836: );
2837: }//SetWindowTopmost
2838:
2839: //*********************************************************
2840: // ShiftDeferDlgItemSize
2841: //*********************************************************
2842: HDWP
2843: ShiftDeferDlgItemSize
2844: (
2845: HDWP *phWinPosInfo,
2846: HWND hWnd,
2847: int nID,
2848: int nX,
2849: int nY
2850: )
2851: {
2852: // パラメタの仮定
2853: ASSERT( IsValidWindow( hWnd ) );
2854: ASSERT( IsValidDlgItem( hWnd, nID ) );
2855: ASSERT( IsValidPtr( phWinPosInfo, sizeof( *phWinPosInfo ) ) );
2856: ASSERT( *phWinPosInfo );
2857:
2858: return ShiftDeferDlgItem( phWinPosInfo, hWnd, nID, 0, 0, nX, nY );
2859: }//ShiftDeferDlgItemSize
2860:
2861: //*********************************************************
2862: // ShiftDeferDlgItem
2863: //*********************************************************
2864: HDWP
2865: ShiftDeferDlgItem
2866: (
2867: HDWP *phWinPosInfo,
2868: HWND hWnd,
2869: int nID,
2870: int nShiftPosX,
2871: int nShiftPosY,
2872: int nShiftSizeX,
2873: int nShiftSizeY
2874: )
2875: {
2876: // パラメタの仮定
2877: ASSERT( IsValidWindow( hWnd ) );
2878: ASSERT( IsValidDlgItem( hWnd, nID ) );
2879: ASSERT( IsValidPtr( phWinPosInfo, sizeof( *phWinPosInfo ) ) );
2880:
2881: HWND hCtrl = GetDlgItem( hWnd, nID );
2882: return ShiftDeferWindow( phWinPosInfo, hCtrl, nShiftPosX, nShiftPosY, nShiftSizeX, nShiftSizeY );
2883: }//ShiftDeferDlgItem
2884:
2885: //*********************************************************
2886: // ShiftDeferWindow
2887: //*********************************************************
2888: HDWP
2889: ShiftDeferWindow
2890: (
2891: HDWP *phWinPosInfo,
2892: HWND hWnd,
2893: int shift_pos_x,
2894: int shift_pos_y,
2895: int shift_size_x,
2896: int shift_size_y
2897: )
2898: {
2899: // パラメタの仮定
2900: ASSERT( IsValidWindow( hWnd ) );
2901: ASSERT( IsValidPtr( phWinPosInfo, sizeof( *phWinPosInfo ) ) );
2902: ASSERT( *phWinPosInfo );
2903:
2904: POINT pt;
2905: GetWindowPoint( hWnd, &pt );
2906:
2907: HWND hParent = GetParent( hWnd );
2908: if ( hParent && IsChild(hParent, hWnd) )
2909: {
2910: ScreenToClient( hParent, &pt );
2911: }
2912:
2913: const int width = GetWindowWidth( hWnd );
2914: const int height = GetWindowHeight( hWnd );
2915: *phWinPosInfo = DeferWindowPos
2916: (
2917: *phWinPosInfo,
2918: hWnd,
2919: null,
2920: pt.x + shift_pos_x,
2921: pt.y + shift_pos_y,
2922: width + shift_size_x,
2923: height + shift_size_y,
2924: SWP_NOACTIVATE | SWP_NOZORDER
2925: );
2926: return *phWinPosInfo;
2927: }//ShiftDeferWindow
2928:
2929: //*********************************************************
2930: // ShiftDeferWindowPos
2931: //*********************************************************
2932: HDWP
2933: ShiftDeferWindowPos
2934: (
2935: HDWP *phWinPosInfo,
2936: HWND hWnd,
2937: int nShiftX,
2938: int nShiftY
2939: )
2940: {
2941: // パラメタの仮定
2942: ASSERT( IsValidWindow( hWnd ) );
2943: ASSERT( IsValidPtr( phWinPosInfo, sizeof( *phWinPosInfo ) ) );
2944: ASSERT( *phWinPosInfo );
2945:
2946: POINT ptWindow;
2947: VERIFY( GetWindowPoint( hWnd, &ptWindow ) );
2948:
2949: HWND hParent = GetParent( hWnd );
2950: if ( hParent && IsChild(hParent,hWnd) )
2951: {
2952: VERIFY( ScreenToClient( hParent, &ptWindow ) );
2953: }
2954:
2955: return DeferWindowMove( phWinPosInfo, hWnd, ptWindow.x + nShiftX, ptWindow.y + nShiftY );
2956: }//ShiftDeferWindowPos
2957:
2958: //*********************************************************
2959: // ShiftDeferWindowSize
2960: //*********************************************************
2961: HDWP
2962: ShiftDeferWindowSize
2963: (
2964: HDWP *phWinPosInfo,
2965: HWND hWnd,
2966: int nShiftX,
2967: int nShiftY
2968: )
2969: {
2970: // パラメタの仮定
2971: ASSERT( IsValidWindow( hWnd ) );
2972: ASSERT( IsValidPtr( phWinPosInfo, sizeof( *phWinPosInfo ) ) );
2973: ASSERT( *phWinPosInfo );
2974:
2975: const int width = GetWindowWidth( hWnd );
2976: const int height = GetWindowHeight( hWnd );
2977: return SetDeferWindowSize( phWinPosInfo, hWnd, width + nShiftX, height + nShiftY );
2978: }//ShiftDeferWindowSize
2979:
2980: //*********************************************************
2981: // ShiftDlgItemPos
2982: //*********************************************************
2983: bool
2984: ShiftDlgItemPos
2985: (
2986: HWND hWnd,
2987: int nID,
2988: int nX,
2989: int nY
2990: )
2991: {
2992: // パラメタの仮定
2993: ASSERT( IsValidWindow( hWnd ) );
2994: ASSERT( IsValidDlgItem( hWnd, nID ) );
2995:
2996: HWND hCtrl = GetDlgItem( hWnd, nID );
2997: return ShiftWindowPos( hCtrl, nX, nY );
2998: }//ShiftDlgItemPos
2999:
3000: //*********************************************************
3001: // ShiftDlgItemSize
3002: //*********************************************************
3003: bool
3004: ShiftDlgItemSize
3005: (
3006: HWND hWnd,
3007: int nID,
3008: int nX,
3009: int nY
3010: )
3011: {
3012: // パラメタの仮定
3013: ASSERT( IsValidWindow( hWnd ) );
3014: ASSERT( IsValidDlgItem( hWnd, nID ) );
3015:
3016: HWND hCtrl = GetDlgItem( hWnd, nID );
3017: return ShiftWindowSize( hCtrl, nX, nY );
3018: }//ShiftDlgItemSize
3019:
3020: //*********************************************************
3021: // ShiftWindowPos
3022: //*********************************************************
3023: bool
3024: ShiftWindowPos
3025: (
3026: HWND hWnd,
3027: int nShiftX,
3028: int nShiftY
3029: )
3030: {
3031: // パラメタの仮定
3032: ASSERT( IsValidWindow( hWnd ) );
3033:
3034: POINT ptWindow;
3035: VERIFY( GetWindowPoint( hWnd, &ptWindow ) );
3036:
3037: HWND hParent = GetParent( hWnd );
3038: if ( hParent && IsChild(hParent,hWnd) )
3039: {
3040: VERIFY( ScreenToClient( hParent, &ptWindow ) );
3041: }
3042:
3043: return WindowMove( hWnd, ptWindow.x + nShiftX, ptWindow.y + nShiftY );
3044: }//ShiftWindowPos
3045:
3046: //*********************************************************
3047: // ShiftWindowSize
3048: //*********************************************************
3049: bool
3050: ShiftWindowSize
3051: (
3052: HWND hWnd,
3053: int nShiftX,
3054: int nShiftY
3055: )
3056: {
3057: // パラメタの仮定
3058: ASSERT( IsValidWindow( hWnd ) );
3059:
3060: const int width = GetWindowWidth( hWnd );
3061: const int height = GetWindowHeight( hWnd );
3062: return SetWindowSize( hWnd, width + nShiftX, height + nShiftY );
3063: }//ShiftWindowSize
3064:
3065:
3066: //------------------------------------------------------------------------------------------------------------------
3067: // t
3068: //------------------------------------------------------------------------------------------------------------------
3069: //*********************************************************
3070: // TopmostWindow
3071: //*********************************************************
3072: bool
3073: TopmostWindow
3074: (
3075: HWND hWnd,
3076: bool bTopmost
3077: )
3078: {
3079: // パラメタの仮定
3080: ASSERT( IsValidWindow( hWnd ) );
3081:
3082: if ( bTopmost )
3083: return SetWindowTopmost( hWnd );
3084: else
3085: return ResetWindowTopmost( hWnd );
3086: }//TopmostWindow
3087:
3088:
3089: //------------------------------------------------------------------------------------------------------------------
3090: // u
3091: //------------------------------------------------------------------------------------------------------------------
3092:
3093: //------------------------------------------------------------------------------------------------------------------
3094: // v
3095: //------------------------------------------------------------------------------------------------------------------
3096: //*********************************************************
3097: // VisibleDlgItem
3098: //*********************************************************
3099: bool
3100: VisibleDlgItem
3101: (
3102: HWND hWnd,
3103: int nID,
3104: bool bVisible
3105: )
3106: {
3107: // パラメタの仮定
3108: ASSERT( IsValidWindow( hWnd ) );
3109: ASSERT( IsValidDlgItem( hWnd, nID ) );
3110:
3111: HWND hCtrl = GetDlgItem( hWnd, nID );
3112: return VisibleWindow( hCtrl, bVisible );
3113: }//VisibleDlgItem
3114:
3115: //*********************************************************
3116: // VisibleWindow
3117: // 疑問: SW_SHOW, SW_SHOWNA のどちらにするべきか……
3118: //*********************************************************
3119: bool
3120: VisibleWindow
3121: (
3122: HWND hWnd,
3123: bool bVisible
3124: )
3125: {
3126: // パラメタの仮定
3127: ASSERT( IsValidWindow( hWnd ) );
3128:
3129: return !! ShowWindow( hWnd, bVisible ? SW_SHOWNA : SW_HIDE );
3130: }//VisibleWindow
3131:
3132:
3133: //------------------------------------------------------------------------------------------------------------------
3134: // w
3135: //------------------------------------------------------------------------------------------------------------------
3136: //*********************************************************
3137: // WindowCaptionMoveToCursorPos
3138: //*********************************************************
3139: bool
3140: WindowCaptionMoveToCursorPos
3141: (
3142: HWND hWnd
3143: )
3144: {
3145: // パラメタの仮定
3146: ASSERT( IsValidWindow( hWnd ) );
3147:
3148: //
3149: POINT pt;
3150: VERIFY( GetCursorPos( &pt ) );
3151: pt.x = pt.x - (GetWindowWidth(hWnd) / 2);
3152: pt.y = pt.y - (GetSystemMetrics(SM_CYCAPTION) / 2);
3153:
3154: // デスクトップ作業領域に表示されるよう移動する
3155: RECT rcWorkarea;
3156: VERIFY( GetWorkareaRect( &rcWorkarea ) );
3157: if ( pt.x > rcWorkarea.right - GetWindowWidth(hWnd) )
3158: pt.x = rcWorkarea.right - GetWindowWidth(hWnd);
3159: if ( pt.x < rcWorkarea.left )
3160: pt.x = rcWorkarea.left;
3161: if ( pt.y > rcWorkarea.bottom - GetWindowHeight(hWnd) )
3162: pt.y = rcWorkarea.bottom - GetWindowHeight(hWnd);
3163: if ( pt.y < rcWorkarea.top )
3164: pt.y = rcWorkarea.top;
3165:
3166: //
3167: HWND hParent = GetParent( hWnd );
3168: if ( hParent && IsChild(hParent, hWnd) )
3169: {
3170: VERIFY( ScreenToClient( hParent, &pt ) );
3171: }
3172:
3173: return WindowMove( hWnd, pt.x, pt.y );
3174: }//WindowCaptionMoveToCursorPos
3175:
3176: //*********************************************************
3177: // WindowToClient
3178: // ウィンドウ座標 pt をクライエント座標に変換する
3179: //*********************************************************
3180: bool
3181: WindowToClient
3182: (
3183: HWND hWnd,
3184: POINT *pt
3185: )
3186: {
3187: // パラメタの仮定
3188: ASSERT( IsValidWindow( hWnd ) );
3189: ASSERT( IsValidPtr( pt, sizeof( *pt ) ) );
3190:
3191: VERIFY( WindowToScreen( hWnd, pt ) );
3192: return boolean_cast( ScreenToClient( hWnd, pt ) );
3193: }//WindowToClient
3194:
3195: //*********************************************************
3196: // WindowToScreen
3197: // ウィンドウ座標 pt をスクリーン座標に変換する
3198: //*********************************************************
3199: bool
3200: WindowToScreen
3201: (
3202: HWND hWnd,
3203: POINT *pt
3204: )
3205: {
3206: // パラメタの仮定
3207: ASSERT( IsValidWindow( hWnd ) );
3208: ASSERT( IsValidPtr( pt, sizeof( *pt ) ) );
3209:
3210: POINT ptWindow;
3211: VERIFY( GetWindowPoint( hWnd, &ptWindow ) );
3212: VERIFY( OffsetPoint( pt, ptWindow.x, ptWindow.y ) );
3213: return true;
3214: }//WindowToScreen
3215:
3216: //*********************************************************
3217: // WindowMove
3218: //*********************************************************
3219: bool
3220: WindowMove
3221: (
3222: HWND hWnd,
3223: int nPosX,
3224: int nPosY
3225: )
3226: {
3227: // パラメタの仮定
3228: ASSERT( IsValidWindow( hWnd ) );
3229:
3230: return !! SetWindowPos( hWnd, null, nPosX, nPosY, 0, 0, SWP_NOSIZE|SWP_NOZORDER );
3231: }//WindowMove
3232:
3233: //*********************************************************
3234: // WindowMoveIntoWorkarea
3235: //*********************************************************
3236: bool
3237: WindowMoveIntoWorkarea
3238: (
3239: HWND hWnd
3240: )
3241: {
3242: // パラメタの仮定
3243: ASSERT( IsValidWindow( hWnd ) );
3244:
3245: //
3246: POINT pt;
3247: RECT rcWindow; // スクリーン座標
3248: GetWindowRect( hWnd, &rcWindow );
3249: MakePoint( &pt, rcWindow.left, rcWindow.top );
3250:
3251: // デスクトップ作業領域に表示されるよう移動する
3252: RECT rcWorkarea;
3253: VERIFY( GetWorkareaRect( &rcWorkarea ) );
3254:
3255: if ( rcWorkarea.right < rcWindow.right )
3256: pt.x = rcWorkarea.right - (rcWindow.right - rcWindow.left);
3257: if ( rcWorkarea.bottom < rcWindow.bottom )
3258: pt.y = rcWorkarea.bottom - (rcWindow.bottom - rcWindow.top);
3259:
3260: if ( rcWindow.left < rcWorkarea.left )
3261: pt.x = rcWorkarea.left;
3262: if ( rcWindow.top < rcWorkarea.top )
3263: pt.y = rcWorkarea.top;
3264:
3265: //
3266: HWND hwndParent = GetParent( hWnd );
3267: if ( hwndParent && IsChild( hwndParent, hWnd ) )
3268: {
3269: VERIFY( ScreenToClient( hwndParent, &pt ) );
3270: }
3271:
3272: return WindowMove( hWnd, pt.x, pt.y );
3273: }//WindowMoveIntoWorkarea
3274:
3275: //*********************************************************
3276: // WindowMoveToCursorPos
3277: //*********************************************************
3278: bool
3279: WindowMoveToCursorPos
3280: (
3281: HWND hWnd
3282: )
3283: {
3284: // パラメタの仮定
3285: ASSERT( IsValidWindow( hWnd ) );
3286:
3287: //
3288: const int width = GetWindowWidth( hWnd );
3289: const int height = GetWindowHeight( hWnd );
3290:
3291: //
3292: POINT pt;
3293: VERIFY( GetCursorPos( &pt ) );
3294: pt.x = pt.x - (width / 2);
3295: pt.y = pt.y - (height / 2);
3296:
3297: // デスクトップ作業領域に表示されるよう移動する
3298: RECT rcWorkarea;
3299: VERIFY( GetWorkareaRect( &rcWorkarea ) );
3300: if ( rcWorkarea.right < pt.x + width )
3301: pt.x = rcWorkarea.right - width;
3302: if ( pt.x < rcWorkarea.left )
3303: pt.x = rcWorkarea.left;
3304: if ( rcWorkarea.bottom < pt.y + height )
3305: pt.y = rcWorkarea.bottom - height;
3306: if ( pt.y < rcWorkarea.top )
3307: pt.y = rcWorkarea.top;
3308:
3309: //
3310: HWND hParent = GetParent( hWnd );
3311: if ( hParent && IsChild(hParent, hWnd) )
3312: {
3313: VERIFY( ScreenToClient( hParent, &pt ) );
3314: }
3315:
3316: return WindowMove( hWnd, pt.x, pt.y );
3317: }//WindowMoveToCursorPos
3318:
3319:
3320: //------------------------------------------------------------------------------------------------------------------
3321: // x
3322: //------------------------------------------------------------------------------------------------------------------
3323:
3324: //------------------------------------------------------------------------------------------------------------------
3325: // y
3326: //------------------------------------------------------------------------------------------------------------------
3327:
3328: //------------------------------------------------------------------------------------------------------------------
3329: // z
3330: //------------------------------------------------------------------------------------------------------------------
3331:
3332:
3333: //** end **
3334:
3335:
参照：
| 水無瀬の部屋 > sample > tools > toolwind.cpp |
|---|
このページは cpp2web が出力しました。
水無瀬 優 postmaster@katsura-kotonoha.sakura.ne.jp
http://katsura-kotonoha.sakura.ne.jp/prog/code/tools/toolwind_cpp.shtml